/*!
 * This file is generated by generate.ts, do not edit it.
 */

export declare enum MATypes {
  SMA = 0,
  EMA = 1,
  WMA = 2,
  DEMA = 3,
  TEMA = 4,
  TRIMA = 5,
  KAMA = 6,
  MAMA = 7,
  T3 = 8
}

export declare interface Record {
  Time: number;
  Open: number;
  High: number;
  Low: number;
  Close: number;
  Volume: number;
}

/**
 * ACCBANDS - Acceleration Bands
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=20] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outRealUpperBand, outRealMiddleBand, outRealLowerBand]
 */
export declare function ACCBANDS(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];
/**
 * ACCBANDS - Acceleration Bands
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=20] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outRealUpperBand, outRealMiddleBand, outRealLowerBand]
 */
export declare function ACCBANDS(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];

/**
 * ACOS - Vector Trigonometric ACos
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ACOS(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ACOS - Vector Trigonometric ACos
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ACOS(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * AD - Chaikin A/D Line
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number[]} inVolume - Volume
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function AD(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  inVolume: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * AD - Chaikin A/D Line
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function AD(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ADD - Vector Arithmetic Add
 *
 * @param {number[]} inReal0 - Double Array
 * @param {number[]} inReal1 - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ADD(
  inReal0: number[],
  inReal1: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ADD - Vector Arithmetic Add
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inReal0Name - The field name to extract from `inRecords`
 * @param {string} inReal1Name - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ADD(
  inRecords: Record[],
  inReal0Name: string,
  inReal1Name: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ADOSC - Chaikin A/D Oscillator
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number[]} inVolume - Volume
 * @param {number} [optFast_Period=3] - Number of period for the fast MA
 * @param {number} [optSlow_Period=10] - Number of period for the slow MA
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ADOSC(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  inVolume: number[],
  optFast_Period?: number,
  optSlow_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ADOSC - Chaikin A/D Oscillator
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optFast_Period=3] - Number of period for the fast MA
 * @param {number} [optSlow_Period=10] - Number of period for the slow MA
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ADOSC(
  inRecords: Record[],
  optFast_Period?: number,
  optSlow_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ADX - Average Directional Movement Index
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ADX(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ADX - Average Directional Movement Index
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ADX(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ADXR - Average Directional Movement Index Rating
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ADXR(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ADXR - Average Directional Movement Index Rating
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ADXR(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * APO - Absolute Price Oscillator
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optFast_Period=12] - Number of period for the fast MA
 * @param {number} [optSlow_Period=26] - Number of period for the slow MA
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function APO(
  inReal: number[],
  optFast_Period?: number,
  optSlow_Period?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * APO - Absolute Price Oscillator
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optFast_Period=12] - Number of period for the fast MA
 * @param {number} [optSlow_Period=26] - Number of period for the slow MA
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function APO(
  inRecords: Record[],
  inRealName: string,
  optFast_Period?: number,
  optSlow_Period?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * AROON - Aroon
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outAroonDown, outAroonUp]
 */
export declare function AROON(
  inHigh: number[],
  inLow: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * AROON - Aroon
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outAroonDown, outAroonUp]
 */
export declare function AROON(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * AROONOSC - Aroon Oscillator
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function AROONOSC(
  inHigh: number[],
  inLow: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * AROONOSC - Aroon Oscillator
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function AROONOSC(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ASIN - Vector Trigonometric ASin
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ASIN(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ASIN - Vector Trigonometric ASin
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ASIN(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ATAN - Vector Trigonometric ATan
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ATAN(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ATAN - Vector Trigonometric ATan
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ATAN(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ATR - Average True Range
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ATR(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ATR - Average True Range
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ATR(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * AVGPRICE - Average Price
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function AVGPRICE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * AVGPRICE - Average Price
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function AVGPRICE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * AVGDEV - Average Deviation
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function AVGDEV(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * AVGDEV - Average Deviation
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function AVGDEV(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * BBANDS - Bollinger Bands
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [optDeviations_up=2.000000e+0] - Deviation multiplier for upper band
 * @param {number} [optDeviations_down=2.000000e+0] - Deviation multiplier for lower band
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outRealUpperBand, outRealMiddleBand, outRealLowerBand]
 */
export declare function BBANDS(
  inReal: number[],
  optTime_Period?: number,
  optDeviations_up?: number,
  optDeviations_down?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];
/**
 * BBANDS - Bollinger Bands
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [optDeviations_up=2.000000e+0] - Deviation multiplier for upper band
 * @param {number} [optDeviations_down=2.000000e+0] - Deviation multiplier for lower band
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outRealUpperBand, outRealMiddleBand, outRealLowerBand]
 */
export declare function BBANDS(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  optDeviations_up?: number,
  optDeviations_down?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];

/**
 * BETA - Beta
 *
 * @param {number[]} inReal0 - Double Array
 * @param {number[]} inReal1 - Double Array
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function BETA(
  inReal0: number[],
  inReal1: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * BETA - Beta
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inReal0Name - The field name to extract from `inRecords`
 * @param {string} inReal1Name - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function BETA(
  inRecords: Record[],
  inReal0Name: string,
  inReal1Name: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * BOP - Balance Of Power
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function BOP(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * BOP - Balance Of Power
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function BOP(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CCI - Commodity Channel Index
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function CCI(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CCI - Commodity Channel Index
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function CCI(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDL2CROWS - Two Crows
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL2CROWS(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDL2CROWS - Two Crows
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL2CROWS(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDL3BLACKCROWS - Three Black Crows
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3BLACKCROWS(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDL3BLACKCROWS - Three Black Crows
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3BLACKCROWS(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDL3INSIDE - Three Inside Up/Down
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3INSIDE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDL3INSIDE - Three Inside Up/Down
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3INSIDE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDL3LINESTRIKE - Three-Line Strike
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3LINESTRIKE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDL3LINESTRIKE - Three-Line Strike
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3LINESTRIKE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDL3OUTSIDE - Three Outside Up/Down
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3OUTSIDE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDL3OUTSIDE - Three Outside Up/Down
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3OUTSIDE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDL3STARSINSOUTH - Three Stars In The South
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3STARSINSOUTH(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDL3STARSINSOUTH - Three Stars In The South
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3STARSINSOUTH(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDL3WHITESOLDIERS - Three Advancing White Soldiers
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3WHITESOLDIERS(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDL3WHITESOLDIERS - Three Advancing White Soldiers
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDL3WHITESOLDIERS(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLABANDONEDBABY - Abandoned Baby
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLABANDONEDBABY(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLABANDONEDBABY - Abandoned Baby
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLABANDONEDBABY(
  inRecords: Record[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLADVANCEBLOCK - Advance Block
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLADVANCEBLOCK(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLADVANCEBLOCK - Advance Block
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLADVANCEBLOCK(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLBELTHOLD - Belt-hold
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLBELTHOLD(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLBELTHOLD - Belt-hold
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLBELTHOLD(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLBREAKAWAY - Breakaway
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLBREAKAWAY(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLBREAKAWAY - Breakaway
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLBREAKAWAY(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLCLOSINGMARUBOZU - Closing Marubozu
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLCLOSINGMARUBOZU(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLCLOSINGMARUBOZU - Closing Marubozu
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLCLOSINGMARUBOZU(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLCONCEALBABYSWALL - Concealing Baby Swallow
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLCONCEALBABYSWALL(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLCONCEALBABYSWALL - Concealing Baby Swallow
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLCONCEALBABYSWALL(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLCOUNTERATTACK - Counterattack
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLCOUNTERATTACK(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLCOUNTERATTACK - Counterattack
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLCOUNTERATTACK(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLDARKCLOUDCOVER - Dark Cloud Cover
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optPenetration=5.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLDARKCLOUDCOVER(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLDARKCLOUDCOVER - Dark Cloud Cover
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optPenetration=5.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLDARKCLOUDCOVER(
  inRecords: Record[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLDOJI - Doji
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLDOJI(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLDOJI - Doji
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLDOJI(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLDOJISTAR - Doji Star
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLDOJISTAR(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLDOJISTAR - Doji Star
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLDOJISTAR(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLDRAGONFLYDOJI - Dragonfly Doji
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLDRAGONFLYDOJI(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLDRAGONFLYDOJI - Dragonfly Doji
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLDRAGONFLYDOJI(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLENGULFING - Engulfing Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLENGULFING(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLENGULFING - Engulfing Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLENGULFING(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLEVENINGDOJISTAR - Evening Doji Star
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLEVENINGDOJISTAR(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLEVENINGDOJISTAR - Evening Doji Star
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLEVENINGDOJISTAR(
  inRecords: Record[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLEVENINGSTAR - Evening Star
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLEVENINGSTAR(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLEVENINGSTAR - Evening Star
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLEVENINGSTAR(
  inRecords: Record[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLGAPSIDESIDEWHITE - Up/Down-gap side-by-side white lines
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLGAPSIDESIDEWHITE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLGAPSIDESIDEWHITE - Up/Down-gap side-by-side white lines
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLGAPSIDESIDEWHITE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLGRAVESTONEDOJI - Gravestone Doji
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLGRAVESTONEDOJI(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLGRAVESTONEDOJI - Gravestone Doji
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLGRAVESTONEDOJI(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLHAMMER - Hammer
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHAMMER(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLHAMMER - Hammer
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHAMMER(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLHANGINGMAN - Hanging Man
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHANGINGMAN(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLHANGINGMAN - Hanging Man
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHANGINGMAN(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLHARAMI - Harami Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHARAMI(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLHARAMI - Harami Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHARAMI(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLHARAMICROSS - Harami Cross Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHARAMICROSS(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLHARAMICROSS - Harami Cross Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHARAMICROSS(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLHIGHWAVE - High-Wave Candle
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHIGHWAVE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLHIGHWAVE - High-Wave Candle
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHIGHWAVE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLHIKKAKE - Hikkake Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHIKKAKE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLHIKKAKE - Hikkake Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHIKKAKE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLHIKKAKEMOD - Modified Hikkake Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHIKKAKEMOD(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLHIKKAKEMOD - Modified Hikkake Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHIKKAKEMOD(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLHOMINGPIGEON - Homing Pigeon
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHOMINGPIGEON(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLHOMINGPIGEON - Homing Pigeon
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLHOMINGPIGEON(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLIDENTICAL3CROWS - Identical Three Crows
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLIDENTICAL3CROWS(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLIDENTICAL3CROWS - Identical Three Crows
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLIDENTICAL3CROWS(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLINNECK - In-Neck Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLINNECK(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLINNECK - In-Neck Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLINNECK(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLINVERTEDHAMMER - Inverted Hammer
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLINVERTEDHAMMER(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLINVERTEDHAMMER - Inverted Hammer
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLINVERTEDHAMMER(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLKICKING - Kicking
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLKICKING(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLKICKING - Kicking
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLKICKING(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLKICKINGBYLENGTH - Kicking - bull/bear determined by the longer marubozu
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLKICKINGBYLENGTH(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLKICKINGBYLENGTH - Kicking - bull/bear determined by the longer marubozu
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLKICKINGBYLENGTH(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLLADDERBOTTOM - Ladder Bottom
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLLADDERBOTTOM(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLLADDERBOTTOM - Ladder Bottom
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLLADDERBOTTOM(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLLONGLEGGEDDOJI - Long Legged Doji
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLLONGLEGGEDDOJI(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLLONGLEGGEDDOJI - Long Legged Doji
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLLONGLEGGEDDOJI(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLLONGLINE - Long Line Candle
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLLONGLINE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLLONGLINE - Long Line Candle
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLLONGLINE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLMARUBOZU - Marubozu
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMARUBOZU(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLMARUBOZU - Marubozu
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMARUBOZU(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLMATCHINGLOW - Matching Low
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMATCHINGLOW(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLMATCHINGLOW - Matching Low
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMATCHINGLOW(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLMATHOLD - Mat Hold
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optPenetration=5.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMATHOLD(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLMATHOLD - Mat Hold
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optPenetration=5.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMATHOLD(
  inRecords: Record[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLMORNINGDOJISTAR - Morning Doji Star
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMORNINGDOJISTAR(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLMORNINGDOJISTAR - Morning Doji Star
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMORNINGDOJISTAR(
  inRecords: Record[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLMORNINGSTAR - Morning Star
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMORNINGSTAR(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLMORNINGSTAR - Morning Star
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optPenetration=3.000000e-1] - Percentage of penetration of a candle within another candle
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLMORNINGSTAR(
  inRecords: Record[],
  optPenetration?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLONNECK - On-Neck Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLONNECK(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLONNECK - On-Neck Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLONNECK(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLPIERCING - Piercing Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLPIERCING(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLPIERCING - Piercing Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLPIERCING(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLRICKSHAWMAN - Rickshaw Man
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLRICKSHAWMAN(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLRICKSHAWMAN - Rickshaw Man
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLRICKSHAWMAN(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLRISEFALL3METHODS - Rising/Falling Three Methods
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLRISEFALL3METHODS(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLRISEFALL3METHODS - Rising/Falling Three Methods
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLRISEFALL3METHODS(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLSEPARATINGLINES - Separating Lines
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSEPARATINGLINES(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLSEPARATINGLINES - Separating Lines
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSEPARATINGLINES(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLSHOOTINGSTAR - Shooting Star
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSHOOTINGSTAR(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLSHOOTINGSTAR - Shooting Star
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSHOOTINGSTAR(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLSHORTLINE - Short Line Candle
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSHORTLINE(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLSHORTLINE - Short Line Candle
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSHORTLINE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLSPINNINGTOP - Spinning Top
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSPINNINGTOP(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLSPINNINGTOP - Spinning Top
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSPINNINGTOP(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLSTALLEDPATTERN - Stalled Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSTALLEDPATTERN(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLSTALLEDPATTERN - Stalled Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSTALLEDPATTERN(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLSTICKSANDWICH - Stick Sandwich
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSTICKSANDWICH(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLSTICKSANDWICH - Stick Sandwich
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLSTICKSANDWICH(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLTAKURI - Takuri (Dragonfly Doji with very long lower shadow)
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLTAKURI(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLTAKURI - Takuri (Dragonfly Doji with very long lower shadow)
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLTAKURI(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLTASUKIGAP - Tasuki Gap
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLTASUKIGAP(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLTASUKIGAP - Tasuki Gap
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLTASUKIGAP(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLTHRUSTING - Thrusting Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLTHRUSTING(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLTHRUSTING - Thrusting Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLTHRUSTING(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLTRISTAR - Tristar Pattern
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLTRISTAR(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLTRISTAR - Tristar Pattern
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLTRISTAR(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLUNIQUE3RIVER - Unique 3 River
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLUNIQUE3RIVER(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLUNIQUE3RIVER - Unique 3 River
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLUNIQUE3RIVER(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLUPSIDEGAP2CROWS - Upside Gap Two Crows
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLUPSIDEGAP2CROWS(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLUPSIDEGAP2CROWS - Upside Gap Two Crows
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLUPSIDEGAP2CROWS(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CDLXSIDEGAP3METHODS - Upside/Downside Gap Three Methods
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLXSIDEGAP3METHODS(
  inOpen: number[],
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CDLXSIDEGAP3METHODS - Upside/Downside Gap Three Methods
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function CDLXSIDEGAP3METHODS(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CEIL - Vector Ceil
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function CEIL(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CEIL - Vector Ceil
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function CEIL(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CMO - Chande Momentum Oscillator
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function CMO(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CMO - Chande Momentum Oscillator
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function CMO(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * CORREL - Pearson's Correlation Coefficient (r)
 *
 * @param {number[]} inReal0 - Double Array
 * @param {number[]} inReal1 - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function CORREL(
  inReal0: number[],
  inReal1: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * CORREL - Pearson's Correlation Coefficient (r)
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inReal0Name - The field name to extract from `inRecords`
 * @param {string} inReal1Name - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function CORREL(
  inRecords: Record[],
  inReal0Name: string,
  inReal1Name: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * COS - Vector Trigonometric Cos
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function COS(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * COS - Vector Trigonometric Cos
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function COS(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * COSH - Vector Trigonometric Cosh
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function COSH(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * COSH - Vector Trigonometric Cosh
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function COSH(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * DEMA - Double Exponential Moving Average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function DEMA(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * DEMA - Double Exponential Moving Average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function DEMA(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * DIV - Vector Arithmetic Div
 *
 * @param {number[]} inReal0 - Double Array
 * @param {number[]} inReal1 - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function DIV(
  inReal0: number[],
  inReal1: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * DIV - Vector Arithmetic Div
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inReal0Name - The field name to extract from `inRecords`
 * @param {string} inReal1Name - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function DIV(
  inRecords: Record[],
  inReal0Name: string,
  inReal1Name: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * DX - Directional Movement Index
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function DX(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * DX - Directional Movement Index
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function DX(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * EMA - Exponential Moving Average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function EMA(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * EMA - Exponential Moving Average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function EMA(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * EXP - Vector Arithmetic Exp
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function EXP(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * EXP - Vector Arithmetic Exp
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function EXP(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * FLOOR - Vector Floor
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function FLOOR(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * FLOOR - Vector Floor
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function FLOOR(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function HT_DCPERIOD(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function HT_DCPERIOD(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function HT_DCPHASE(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function HT_DCPHASE(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * HT_PHASOR - Hilbert Transform - Phasor Components
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outInPhase, outQuadrature]
 */
export declare function HT_PHASOR(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * HT_PHASOR - Hilbert Transform - Phasor Components
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outInPhase, outQuadrature]
 */
export declare function HT_PHASOR(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * HT_SINE - Hilbert Transform - SineWave
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outSine, outLeadSine]
 */
export declare function HT_SINE(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * HT_SINE - Hilbert Transform - SineWave
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outSine, outLeadSine]
 */
export declare function HT_SINE(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function HT_TRENDLINE(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function HT_TRENDLINE(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * HT_TRENDMODE - Hilbert Transform - Trend vs Cycle Mode
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function HT_TRENDMODE(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * HT_TRENDMODE - Hilbert Transform - Trend vs Cycle Mode
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function HT_TRENDMODE(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * IMI - Intraday Momentum Index
 *
 * @param {number[]} inOpen - Open
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function IMI(
  inOpen: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * IMI - Intraday Momentum Index
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function IMI(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * KAMA - Kaufman Adaptive Moving Average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function KAMA(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * KAMA - Kaufman Adaptive Moving Average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function KAMA(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * LINEARREG - Linear Regression
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LINEARREG(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * LINEARREG - Linear Regression
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LINEARREG(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * LINEARREG_ANGLE - Linear Regression Angle
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LINEARREG_ANGLE(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * LINEARREG_ANGLE - Linear Regression Angle
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LINEARREG_ANGLE(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * LINEARREG_INTERCEPT - Linear Regression Intercept
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LINEARREG_INTERCEPT(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * LINEARREG_INTERCEPT - Linear Regression Intercept
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LINEARREG_INTERCEPT(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * LINEARREG_SLOPE - Linear Regression Slope
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LINEARREG_SLOPE(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * LINEARREG_SLOPE - Linear Regression Slope
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LINEARREG_SLOPE(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * LN - Vector Log Natural
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LN(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * LN - Vector Log Natural
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LN(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * LOG10 - Vector Log10
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LOG10(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * LOG10 - Vector Log10
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function LOG10(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MA - Moving average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MA(
  inReal: number[],
  optTime_Period?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MA - Moving average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MA(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MACD - Moving Average Convergence/Divergence
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optFast_Period=12] - Number of period for the fast MA
 * @param {number} [optSlow_Period=26] - Number of period for the slow MA
 * @param {number} [optSignal_Period=9] - Smoothing for the signal line (nb of period)
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outMACD, outMACDSignal, outMACDHist]
 */
export declare function MACD(
  inReal: number[],
  optFast_Period?: number,
  optSlow_Period?: number,
  optSignal_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];
/**
 * MACD - Moving Average Convergence/Divergence
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optFast_Period=12] - Number of period for the fast MA
 * @param {number} [optSlow_Period=26] - Number of period for the slow MA
 * @param {number} [optSignal_Period=9] - Smoothing for the signal line (nb of period)
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outMACD, outMACDSignal, outMACDHist]
 */
export declare function MACD(
  inRecords: Record[],
  inRealName: string,
  optFast_Period?: number,
  optSlow_Period?: number,
  optSignal_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];

/**
 * MACDEXT - MACD with controllable MA type
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optFast_Period=12] - Number of period for the fast MA
 * @param {MATypes} [optFast_MA=SMA] - Type of Moving Average for fast MA
 * @param {number} [optSlow_Period=26] - Number of period for the slow MA
 * @param {MATypes} [optSlow_MA=SMA] - Type of Moving Average for slow MA
 * @param {number} [optSignal_Period=9] - Smoothing for the signal line (nb of period)
 * @param {MATypes} [optSignal_MA=SMA] - Type of Moving Average for signal line
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outMACD, outMACDSignal, outMACDHist]
 */
export declare function MACDEXT(
  inReal: number[],
  optFast_Period?: number,
  optFast_MA?: MATypes,
  optSlow_Period?: number,
  optSlow_MA?: MATypes,
  optSignal_Period?: number,
  optSignal_MA?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];
/**
 * MACDEXT - MACD with controllable MA type
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optFast_Period=12] - Number of period for the fast MA
 * @param {MATypes} [optFast_MA=SMA] - Type of Moving Average for fast MA
 * @param {number} [optSlow_Period=26] - Number of period for the slow MA
 * @param {MATypes} [optSlow_MA=SMA] - Type of Moving Average for slow MA
 * @param {number} [optSignal_Period=9] - Smoothing for the signal line (nb of period)
 * @param {MATypes} [optSignal_MA=SMA] - Type of Moving Average for signal line
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outMACD, outMACDSignal, outMACDHist]
 */
export declare function MACDEXT(
  inRecords: Record[],
  inRealName: string,
  optFast_Period?: number,
  optFast_MA?: MATypes,
  optSlow_Period?: number,
  optSlow_MA?: MATypes,
  optSignal_Period?: number,
  optSignal_MA?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];

/**
 * MACDFIX - Moving Average Convergence/Divergence Fix 12/26
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optSignal_Period=9] - Smoothing for the signal line (nb of period)
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outMACD, outMACDSignal, outMACDHist]
 */
export declare function MACDFIX(
  inReal: number[],
  optSignal_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];
/**
 * MACDFIX - Moving Average Convergence/Divergence Fix 12/26
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optSignal_Period=9] - Smoothing for the signal line (nb of period)
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[], number[]]} - [outMACD, outMACDSignal, outMACDHist]
 */
export declare function MACDFIX(
  inRecords: Record[],
  inRealName: string,
  optSignal_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[], number[]];

/**
 * MAMA - MESA Adaptive Moving Average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optFast_Limit=5.000000e-1] - Upper limit use in the adaptive algorithm
 * @param {number} [optSlow_Limit=5.000000e-2] - Lower limit use in the adaptive algorithm
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outMAMA, outFAMA]
 */
export declare function MAMA(
  inReal: number[],
  optFast_Limit?: number,
  optSlow_Limit?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * MAMA - MESA Adaptive Moving Average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optFast_Limit=5.000000e-1] - Upper limit use in the adaptive algorithm
 * @param {number} [optSlow_Limit=5.000000e-2] - Lower limit use in the adaptive algorithm
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outMAMA, outFAMA]
 */
export declare function MAMA(
  inRecords: Record[],
  inRealName: string,
  optFast_Limit?: number,
  optSlow_Limit?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * MAVP - Moving average with variable period
 *
 * @param {number[]} inReal - Double Array
 * @param {number[]} inPeriods - Double Array
 * @param {number} [optMinimum_Period=2] - Value less than minimum will be changed to Minimum period
 * @param {number} [optMaximum_Period=30] - Value higher than maximum will be changed to Maximum period
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MAVP(
  inReal: number[],
  inPeriods: number[],
  optMinimum_Period?: number,
  optMaximum_Period?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MAVP - Moving average with variable period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {string} inPeriodsName - The field name to extract from `inRecords`
 * @param {number} [optMinimum_Period=2] - Value less than minimum will be changed to Minimum period
 * @param {number} [optMaximum_Period=30] - Value higher than maximum will be changed to Maximum period
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MAVP(
  inRecords: Record[],
  inRealName: string,
  inPeriodsName: string,
  optMinimum_Period?: number,
  optMaximum_Period?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MAX - Highest value over a specified period
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MAX(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MAX - Highest value over a specified period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MAX(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MAXINDEX - Index of highest value over a specified period
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function MAXINDEX(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MAXINDEX - Index of highest value over a specified period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function MAXINDEX(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MEDPRICE - Median Price
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MEDPRICE(
  inHigh: number[],
  inLow: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MEDPRICE - Median Price
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MEDPRICE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MFI - Money Flow Index
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number[]} inVolume - Volume
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MFI(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  inVolume: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MFI - Money Flow Index
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MFI(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MIDPOINT - MidPoint over period
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MIDPOINT(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MIDPOINT - MidPoint over period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MIDPOINT(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MIDPRICE - Midpoint Price over period
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MIDPRICE(
  inHigh: number[],
  inLow: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MIDPRICE - Midpoint Price over period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MIDPRICE(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MIN - Lowest value over a specified period
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MIN(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MIN - Lowest value over a specified period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MIN(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MININDEX - Index of lowest value over a specified period
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function MININDEX(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MININDEX - Index of lowest value over a specified period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outInteger (Integer Array)
 */
export declare function MININDEX(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MINMAX - Lowest and highest values over a specified period
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outMin, outMax]
 */
export declare function MINMAX(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * MINMAX - Lowest and highest values over a specified period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outMin, outMax]
 */
export declare function MINMAX(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * MINMAXINDEX - Indexes of lowest and highest values over a specified period
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outMinIdx, outMaxIdx]
 */
export declare function MINMAXINDEX(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * MINMAXINDEX - Indexes of lowest and highest values over a specified period
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outMinIdx, outMaxIdx]
 */
export declare function MINMAXINDEX(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * MINUS_DI - Minus Directional Indicator
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MINUS_DI(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MINUS_DI - Minus Directional Indicator
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MINUS_DI(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MINUS_DM - Minus Directional Movement
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MINUS_DM(
  inHigh: number[],
  inLow: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MINUS_DM - Minus Directional Movement
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MINUS_DM(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MOM - Momentum
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MOM(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MOM - Momentum
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MOM(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * MULT - Vector Arithmetic Mult
 *
 * @param {number[]} inReal0 - Double Array
 * @param {number[]} inReal1 - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MULT(
  inReal0: number[],
  inReal1: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * MULT - Vector Arithmetic Mult
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inReal0Name - The field name to extract from `inRecords`
 * @param {string} inReal1Name - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function MULT(
  inRecords: Record[],
  inReal0Name: string,
  inReal1Name: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * NATR - Normalized Average True Range
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function NATR(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * NATR - Normalized Average True Range
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function NATR(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * OBV - On Balance Volume
 *
 * @param {number[]} inReal - Double Array
 * @param {number[]} inVolume - Volume
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function OBV(
  inReal: number[],
  inVolume: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * OBV - On Balance Volume
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function OBV(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * PLUS_DI - Plus Directional Indicator
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function PLUS_DI(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * PLUS_DI - Plus Directional Indicator
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function PLUS_DI(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * PLUS_DM - Plus Directional Movement
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function PLUS_DM(
  inHigh: number[],
  inLow: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * PLUS_DM - Plus Directional Movement
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function PLUS_DM(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * PPO - Percentage Price Oscillator
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optFast_Period=12] - Number of period for the fast MA
 * @param {number} [optSlow_Period=26] - Number of period for the slow MA
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function PPO(
  inReal: number[],
  optFast_Period?: number,
  optSlow_Period?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * PPO - Percentage Price Oscillator
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optFast_Period=12] - Number of period for the fast MA
 * @param {number} [optSlow_Period=26] - Number of period for the slow MA
 * @param {MATypes} [optMA_Type=SMA] - Type of Moving Average
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function PPO(
  inRecords: Record[],
  inRealName: string,
  optFast_Period?: number,
  optSlow_Period?: number,
  optMA_Type?: MATypes,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ROC - Rate of change : ((price/prevPrice)-1)*100
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ROC(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ROC - Rate of change : ((price/prevPrice)-1)*100
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ROC(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ROCP(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ROCP(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ROCR - Rate of change ratio: (price/prevPrice)
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ROCR(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ROCR - Rate of change ratio: (price/prevPrice)
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ROCR(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ROCR100(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=10] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ROCR100(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * RSI - Relative Strength Index
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function RSI(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * RSI - Relative Strength Index
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function RSI(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * SAR - Parabolic SAR
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number} [optAcceleration_Factor=2.000000e-2] - Acceleration Factor used up to the Maximum value
 * @param {number} [optAF_Maximum=2.000000e-1] - Acceleration Factor Maximum value
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SAR(
  inHigh: number[],
  inLow: number[],
  optAcceleration_Factor?: number,
  optAF_Maximum?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * SAR - Parabolic SAR
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optAcceleration_Factor=2.000000e-2] - Acceleration Factor used up to the Maximum value
 * @param {number} [optAF_Maximum=2.000000e-1] - Acceleration Factor Maximum value
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SAR(
  inRecords: Record[],
  optAcceleration_Factor?: number,
  optAF_Maximum?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * SAREXT - Parabolic SAR - Extended
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number} [optStart_Value=0.000000e+0] - Start value and direction. 0 for Auto, >0 for Long, <0 for Short
 * @param {number} [optOffset_on_Reverse=0.000000e+0] - Percent offset added/removed to initial stop on short/long reversal
 * @param {number} [optAF_Init_Long=2.000000e-2] - Acceleration Factor initial value for the Long direction
 * @param {number} [optAF_Long=2.000000e-2] - Acceleration Factor for the Long direction
 * @param {number} [optAF_Max_Long=2.000000e-1] - Acceleration Factor maximum value for the Long direction
 * @param {number} [optAF_Init_Short=2.000000e-2] - Acceleration Factor initial value for the Short direction
 * @param {number} [optAF_Short=2.000000e-2] - Acceleration Factor for the Short direction
 * @param {number} [optAF_Max_Short=2.000000e-1] - Acceleration Factor maximum value for the Short direction
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SAREXT(
  inHigh: number[],
  inLow: number[],
  optStart_Value?: number,
  optOffset_on_Reverse?: number,
  optAF_Init_Long?: number,
  optAF_Long?: number,
  optAF_Max_Long?: number,
  optAF_Init_Short?: number,
  optAF_Short?: number,
  optAF_Max_Short?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * SAREXT - Parabolic SAR - Extended
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optStart_Value=0.000000e+0] - Start value and direction. 0 for Auto, >0 for Long, <0 for Short
 * @param {number} [optOffset_on_Reverse=0.000000e+0] - Percent offset added/removed to initial stop on short/long reversal
 * @param {number} [optAF_Init_Long=2.000000e-2] - Acceleration Factor initial value for the Long direction
 * @param {number} [optAF_Long=2.000000e-2] - Acceleration Factor for the Long direction
 * @param {number} [optAF_Max_Long=2.000000e-1] - Acceleration Factor maximum value for the Long direction
 * @param {number} [optAF_Init_Short=2.000000e-2] - Acceleration Factor initial value for the Short direction
 * @param {number} [optAF_Short=2.000000e-2] - Acceleration Factor for the Short direction
 * @param {number} [optAF_Max_Short=2.000000e-1] - Acceleration Factor maximum value for the Short direction
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SAREXT(
  inRecords: Record[],
  optStart_Value?: number,
  optOffset_on_Reverse?: number,
  optAF_Init_Long?: number,
  optAF_Long?: number,
  optAF_Max_Long?: number,
  optAF_Init_Short?: number,
  optAF_Short?: number,
  optAF_Max_Short?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * SIN - Vector Trigonometric Sin
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SIN(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * SIN - Vector Trigonometric Sin
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SIN(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * SINH - Vector Trigonometric Sinh
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SINH(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * SINH - Vector Trigonometric Sinh
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SINH(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * SMA - Simple Moving Average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SMA(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * SMA - Simple Moving Average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SMA(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * SQRT - Vector Square Root
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SQRT(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * SQRT - Vector Square Root
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SQRT(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * STDDEV - Standard Deviation
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [optDeviations=1.000000e+0] - Nb of deviations
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function STDDEV(
  inReal: number[],
  optTime_Period?: number,
  optDeviations?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * STDDEV - Standard Deviation
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [optDeviations=1.000000e+0] - Nb of deviations
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function STDDEV(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  optDeviations?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * STOCH - Stochastic
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optFastK_Period=5] - Time period for building the Fast-K line
 * @param {number} [optSlowK_Period=3] - Smoothing for making the Slow-K line. Usually set to 3
 * @param {MATypes} [optSlowK_MA=SMA] - Type of Moving Average for Slow-K
 * @param {number} [optSlowD_Period=3] - Smoothing for making the Slow-D line
 * @param {MATypes} [optSlowD_MA=SMA] - Type of Moving Average for Slow-D
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outSlowK, outSlowD]
 */
export declare function STOCH(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optFastK_Period?: number,
  optSlowK_Period?: number,
  optSlowK_MA?: MATypes,
  optSlowD_Period?: number,
  optSlowD_MA?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * STOCH - Stochastic
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optFastK_Period=5] - Time period for building the Fast-K line
 * @param {number} [optSlowK_Period=3] - Smoothing for making the Slow-K line. Usually set to 3
 * @param {MATypes} [optSlowK_MA=SMA] - Type of Moving Average for Slow-K
 * @param {number} [optSlowD_Period=3] - Smoothing for making the Slow-D line
 * @param {MATypes} [optSlowD_MA=SMA] - Type of Moving Average for Slow-D
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outSlowK, outSlowD]
 */
export declare function STOCH(
  inRecords: Record[],
  optFastK_Period?: number,
  optSlowK_Period?: number,
  optSlowK_MA?: MATypes,
  optSlowD_Period?: number,
  optSlowD_MA?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * STOCHF - Stochastic Fast
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optFastK_Period=5] - Time period for building the Fast-K line
 * @param {number} [optFastD_Period=3] - Smoothing for making the Fast-D line. Usually set to 3
 * @param {MATypes} [optFastD_MA=SMA] - Type of Moving Average for Fast-D
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outFastK, outFastD]
 */
export declare function STOCHF(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optFastK_Period?: number,
  optFastD_Period?: number,
  optFastD_MA?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * STOCHF - Stochastic Fast
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optFastK_Period=5] - Time period for building the Fast-K line
 * @param {number} [optFastD_Period=3] - Smoothing for making the Fast-D line. Usually set to 3
 * @param {MATypes} [optFastD_MA=SMA] - Type of Moving Average for Fast-D
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outFastK, outFastD]
 */
export declare function STOCHF(
  inRecords: Record[],
  optFastK_Period?: number,
  optFastD_Period?: number,
  optFastD_MA?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * STOCHRSI - Stochastic Relative Strength Index
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [optFastK_Period=5] - Time period for building the Fast-K line
 * @param {number} [optFastD_Period=3] - Smoothing for making the Fast-D line. Usually set to 3
 * @param {MATypes} [optFastD_MA=SMA] - Type of Moving Average for Fast-D
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outFastK, outFastD]
 */
export declare function STOCHRSI(
  inReal: number[],
  optTime_Period?: number,
  optFastK_Period?: number,
  optFastD_Period?: number,
  optFastD_MA?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];
/**
 * STOCHRSI - Stochastic Relative Strength Index
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [optFastK_Period=5] - Time period for building the Fast-K line
 * @param {number} [optFastD_Period=3] - Smoothing for making the Fast-D line. Usually set to 3
 * @param {MATypes} [optFastD_MA=SMA] - Type of Moving Average for Fast-D
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {[number[], number[]]} - [outFastK, outFastD]
 */
export declare function STOCHRSI(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  optFastK_Period?: number,
  optFastD_Period?: number,
  optFastD_MA?: MATypes,
  startIdx?: number,
  endIdx?: number
): [number[], number[]];

/**
 * SUB - Vector Arithmetic Substraction
 *
 * @param {number[]} inReal0 - Double Array
 * @param {number[]} inReal1 - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SUB(
  inReal0: number[],
  inReal1: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * SUB - Vector Arithmetic Substraction
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inReal0Name - The field name to extract from `inRecords`
 * @param {string} inReal1Name - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SUB(
  inRecords: Record[],
  inReal0Name: string,
  inReal1Name: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * SUM - Summation
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SUM(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * SUM - Summation
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function SUM(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * T3 - Triple Exponential Moving Average (T3)
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [optVolume_Factor=7.000000e-1] - Volume Factor
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function T3(
  inReal: number[],
  optTime_Period?: number,
  optVolume_Factor?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * T3 - Triple Exponential Moving Average (T3)
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [optVolume_Factor=7.000000e-1] - Volume Factor
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function T3(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  optVolume_Factor?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * TAN - Vector Trigonometric Tan
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TAN(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * TAN - Vector Trigonometric Tan
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TAN(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * TANH - Vector Trigonometric Tanh
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TANH(
  inReal: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * TANH - Vector Trigonometric Tanh
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TANH(
  inRecords: Record[],
  inRealName: string,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * TEMA - Triple Exponential Moving Average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TEMA(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * TEMA - Triple Exponential Moving Average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TEMA(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * TRANGE - True Range
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TRANGE(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * TRANGE - True Range
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TRANGE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * TRIMA - Triangular Moving Average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TRIMA(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * TRIMA - Triangular Moving Average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TRIMA(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TRIX(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TRIX(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * TSF - Time Series Forecast
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TSF(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * TSF - Time Series Forecast
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TSF(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * TYPPRICE - Typical Price
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TYPPRICE(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * TYPPRICE - Typical Price
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function TYPPRICE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * ULTOSC - Ultimate Oscillator
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optFirst_Period=7] - Number of bars for 1st period.
 * @param {number} [optSecond_Period=14] - Number of bars fro 2nd period
 * @param {number} [optThird_Period=28] - Number of bars for 3rd period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ULTOSC(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optFirst_Period?: number,
  optSecond_Period?: number,
  optThird_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * ULTOSC - Ultimate Oscillator
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optFirst_Period=7] - Number of bars for 1st period.
 * @param {number} [optSecond_Period=14] - Number of bars fro 2nd period
 * @param {number} [optThird_Period=28] - Number of bars for 3rd period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function ULTOSC(
  inRecords: Record[],
  optFirst_Period?: number,
  optSecond_Period?: number,
  optThird_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * VAR - Variance
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [optDeviations=1.000000e+0] - Nb of deviations
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function VAR(
  inReal: number[],
  optTime_Period?: number,
  optDeviations?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * VAR - Variance
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=5] - Number of period
 * @param {number} [optDeviations=1.000000e+0] - Nb of deviations
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function VAR(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  optDeviations?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * WCLPRICE - Weighted Close Price
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function WCLPRICE(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * WCLPRICE - Weighted Close Price
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function WCLPRICE(
  inRecords: Record[],
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * WILLR - Williams' %R
 *
 * @param {number[]} inHigh - High
 * @param {number[]} inLow - Low
 * @param {number[]} inClose - Close
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function WILLR(
  inHigh: number[],
  inLow: number[],
  inClose: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * WILLR - Williams' %R
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {number} [optTime_Period=14] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function WILLR(
  inRecords: Record[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];

/**
 * WMA - Weighted Moving Average
 *
 * @param {number[]} inReal - Double Array
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength-1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function WMA(
  inReal: number[],
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];
/**
 * WMA - Weighted Moving Average
 *
 * @param {Record[]} inRecords - The records to extract data
 * @param {string} inRealName - The field name to extract from `inRecords`
 * @param {number} [optTime_Period=30] - Number of period
 * @param {number} [startIdx=0] - The start index to process
 * @param {number} [endIdx=inLength - 1] - The end index to process, please not that the value is included, default is the input records length - 1
 * @returns {number[]} - outReal (Double Array)
 */
export declare function WMA(
  inRecords: Record[],
  inRealName: string,
  optTime_Period?: number,
  startIdx?: number,
  endIdx?: number
): number[];