
        
import * as _lib from "./pkg_napi/index.js";
  
        
export function accdist(ctx, ) {
    return _lib.Incr_fn_accdist_a6139b.make(ctx, ).collect()
  }

class AccdistLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Accdist {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_accdist_a6139b.make(this.ctx, );
    this.locals = AccdistLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next() {
    return this.inner.next()
  }
}
    

export function cum(ctx, src, ) {
    return _lib.Incr_fn_cum_affd1d.make(ctx, ).collect(src)
  }

class CumLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Cum {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_cum_affd1d.make(this.ctx, );
    this.locals = CumLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src) {
    return this.inner.next(src)
  }
}
    

export function change(ctx, src, ) {
    return _lib.Incr_fn_change_4c3ac8.make(ctx, ).collect(src)
  }

class ChangeLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Change {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_change_4c3ac8.make(this.ctx, );
    this.locals = ChangeLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src) {
    return this.inner.next(src)
  }
}
    

export function barssince(ctx, condition, ) {
    return _lib.Incr_fn_barssince_23828f.make(ctx, ).collect(condition)
  }

class BarssinceLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Barssince {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_barssince_23828f.make(this.ctx, );
    this.locals = BarssinceLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(condition) {
    return this.inner.next(condition)
  }
}
    

export function roc(ctx, src, length, ) {
    return _lib.Incr_fn_roc_68792d.make(ctx, ).collect(src, length)
  }

class RocLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Roc {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_roc_68792d.make(this.ctx, );
    this.locals = RocLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function crossover(ctx, source1, source2, ) {
    return _lib.Incr_fn_crossover_00b6d7.make(ctx, ).collect(source1, source2)
  }

class CrossoverLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Crossover {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_crossover_00b6d7.make(this.ctx, );
    this.locals = CrossoverLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(source1, source2) {
    return this.inner.next(source1, source2)
  }
}
    

export function crossunder(ctx, source1, source2, ) {
    return _lib.Incr_fn_crossunder_03161e.make(ctx, ).collect(source1, source2)
  }

class CrossunderLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Crossunder {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_crossunder_03161e.make(this.ctx, );
    this.locals = CrossunderLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(source1, source2) {
    return this.inner.next(source1, source2)
  }
}
    

export function cross(ctx, source1, source2, ) {
    return _lib.Incr_fn_cross_904423.make(ctx, ).collect(source1, source2)
  }

class CrossLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Cross {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_cross_904423.make(this.ctx, );
    this.locals = CrossLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(source1, source2) {
    return this.inner.next(source1, source2)
  }
}
    

export function highestbars(ctx, src, length, ) {
    return _lib.Incr_fn_highestbars_a94c2b.make(ctx, ).collect(src, length)
  }

class HighestbarsLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Highestbars {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_highestbars_a94c2b.make(this.ctx, );
    this.locals = HighestbarsLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function lowestbars(ctx, src, length, ) {
    return _lib.Incr_fn_lowestbars_689437.make(ctx, ).collect(src, length)
  }

class LowestbarsLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Lowestbars {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_lowestbars_689437.make(this.ctx, );
    this.locals = LowestbarsLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function highest(ctx, src, length, ) {
    return _lib.Incr_fn_highest_953503.make(ctx, ).collect(src, length)
  }

class HighestLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Highest {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_highest_953503.make(this.ctx, );
    this.locals = HighestLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function lowest(ctx, src, length, ) {
    return _lib.Incr_fn_lowest_a3ed9b.make(ctx, ).collect(src, length)
  }

class LowestLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Lowest {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_lowest_a3ed9b.make(this.ctx, );
    this.locals = LowestLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function swma(ctx, src, ) {
    return _lib.Incr_fn_swma_f6ed4f.make(ctx, ).collect(src)
  }

class SwmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Swma {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_swma_f6ed4f.make(this.ctx, );
    this.locals = SwmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src) {
    return this.inner.next(src)
  }
}
    

export function sma(ctx, src, length, ) {
    return _lib.Incr_fn_sma_b7b0be.make(ctx, ).collect(src, length)
  }

class SmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Sma {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_sma_b7b0be.make(this.ctx, );
    this.locals = SmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function ema(ctx, src, length, ) {
    return _lib.Incr_fn_ema_c485e3.make(ctx, ).collect(src, length)
  }

class EmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Ema {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_ema_c485e3.make(this.ctx, );
    this.locals = EmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function rma(ctx, src, length, ) {
    return _lib.Incr_fn_rma_ea70bf.make(ctx, ).collect(src, length)
  }

class RmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Rma {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_rma_ea70bf.make(this.ctx, );
    this.locals = RmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function wma(ctx, src, length, ) {
    return _lib.Incr_fn_wma_6eb905.make(ctx, ).collect(src, length)
  }

class WmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Wma {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_wma_6eb905.make(this.ctx, );
    this.locals = WmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function lwma(ctx, src, length, ) {
    return _lib.Incr_fn_lwma_28b1da.make(ctx, ).collect(src, length)
  }

class LwmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Lwma {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_lwma_28b1da.make(this.ctx, );
    this.locals = LwmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function hma(ctx, src, length, ) {
    return _lib.Incr_fn_hma_709be9.make(ctx, ).collect(src, length)
  }

class HmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Hma {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_hma_709be9.make(this.ctx, );
    this.locals = HmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function vwma(ctx, src, length, ) {
    return _lib.Incr_fn_vwma_116001.make(ctx, ).collect(src, length)
  }

class VwmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Vwma {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_vwma_116001.make(this.ctx, );
    this.locals = VwmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function dev(ctx, src, length, ) {
    return _lib.Incr_fn_dev_279d49.make(ctx, ).collect(src, length)
  }

class DevLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Dev {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_dev_279d49.make(this.ctx, );
    this.locals = DevLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function tr(ctx, handle_na, ) {
    return _lib.Incr_fn_tr_624b3c.make(ctx, ).collect(handle_na)
  }

class TrLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Tr {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_tr_624b3c.make(this.ctx, );
    this.locals = TrLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(handle_na) {
    return this.inner.next(handle_na)
  }
}
    

export function atr(ctx, length, ) {
    return _lib.Incr_fn_atr_60799e.make(ctx, ).collect(length)
  }

class AtrLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Atr {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_atr_60799e.make(this.ctx, );
    this.locals = AtrLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function rsi(ctx, src, length, ) {
    return _lib.Incr_fn_rsi_7e17dd.make(ctx, ).collect(src, length)
  }

class RsiLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Rsi {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_rsi_7e17dd.make(this.ctx, );
    this.locals = RsiLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function cci(ctx, src, length, ) {
    return _lib.Incr_fn_cci_d2d14f.make(ctx, ).collect(src, length)
  }

class CciLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Cci {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_cci_d2d14f.make(this.ctx, );
    this.locals = CciLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function stdev(ctx, src, length, biased, ) {
    return _lib.Incr_fn_stdev_67ab0a.make(ctx, ).collect(src, length, biased)
  }

class StdevLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Stdev {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_stdev_67ab0a.make(this.ctx, );
    this.locals = StdevLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length, biased) {
    return this.inner.next(src, length, biased)
  }
}
    

export function aroon(ctx, length, ) {
    return _lib.Incr_fn_aroon_0fc1da.make(ctx, ).collect(length)
  }

class AroonLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Aroon {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_aroon_0fc1da.make(this.ctx, );
    this.locals = AroonLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function supertrend(ctx, src, factor, atr_period, ) {
    return _lib.Incr_fn_supertrend_4850c9.make(ctx, ).collect(src, factor, atr_period)
  }

class SupertrendLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Supertrend {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_supertrend_4850c9.make(this.ctx, );
    this.locals = SupertrendLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, factor, atr_period) {
    return this.inner.next(src, factor, atr_period)
  }
}
    

export function awesomeOscillator(ctx, src, slow_length, fast_length, ) {
    return _lib.Incr_fn_awesome_oscillator_1729a8.make(ctx, ).collect(src, slow_length, fast_length)
  }

class AwesomeOscillatorLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class AwesomeOscillator {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_awesome_oscillator_1729a8.make(this.ctx, );
    this.locals = AwesomeOscillatorLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, slow_length, fast_length) {
    return this.inner.next(src, slow_length, fast_length)
  }
}
    

export function balanceOfPower(ctx, ) {
    return _lib.Incr_fn_balance_of_power_8cd6da.make(ctx, ).collect()
  }

class BalanceOfPowerLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class BalanceOfPower {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_balance_of_power_8cd6da.make(this.ctx, );
    this.locals = BalanceOfPowerLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next() {
    return this.inner.next()
  }
}
    

export function bollingerBandsPctB(ctx, src, length, mult, ) {
    return _lib.Incr_fn_bollinger_bands_pct_b_409315.make(ctx, ).collect(src, length, mult)
  }

class BollingerBandsPctBLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class BollingerBandsPctB {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_bollinger_bands_pct_b_409315.make(this.ctx, );
    this.locals = BollingerBandsPctBLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length, mult) {
    return this.inner.next(src, length, mult)
  }
}
    

export function bollingerBandsWidth(ctx, src, length, mult, ) {
    return _lib.Incr_fn_bollinger_bands_width_b0b5cf.make(ctx, ).collect(src, length, mult)
  }

class BollingerBandsWidthLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class BollingerBandsWidth {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_bollinger_bands_width_b0b5cf.make(this.ctx, );
    this.locals = BollingerBandsWidthLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length, mult) {
    return this.inner.next(src, length, mult)
  }
}
    

export function bollingerBands(ctx, src, length, mult, ) {
    return _lib.Incr_fn_bollinger_bands_064d07.make(ctx, ).collect(src, length, mult)
  }

class BollingerBandsLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class BollingerBands {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_bollinger_bands_064d07.make(this.ctx, );
    this.locals = BollingerBandsLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length, mult) {
    return this.inner.next(src, length, mult)
  }
}
    

export function chaikinMoneyFlow(ctx, length, ) {
    return _lib.Incr_fn_chaikin_money_flow_2cbc46.make(ctx, ).collect(length)
  }

class ChaikinMoneyFlowLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

    get cumVol() {
        return this.__inner._7700_cumVol()
  }
  
      
}

export class ChaikinMoneyFlow {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_chaikin_money_flow_2cbc46.make(this.ctx, );
    this.locals = ChaikinMoneyFlowLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function chandeKrollStop(ctx, atr_length, atr_coeff, stop_length, ) {
    return _lib.Incr_fn_chande_kroll_stop_bc52b9.make(ctx, ).collect(atr_length, atr_coeff, stop_length)
  }

class ChandeKrollStopLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class ChandeKrollStop {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_chande_kroll_stop_bc52b9.make(this.ctx, );
    this.locals = ChandeKrollStopLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(atr_length, atr_coeff, stop_length) {
    return this.inner.next(atr_length, atr_coeff, stop_length)
  }
}
    

export function choppinessIndex(ctx, length, ) {
    return _lib.Incr_fn_choppiness_index_c5927b.make(ctx, ).collect(length)
  }

class ChoppinessIndexLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class ChoppinessIndex {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_choppiness_index_c5927b.make(this.ctx, );
    this.locals = ChoppinessIndexLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function connorsRsi(ctx, src, rsi_length, up_down_length, roc_length, ) {
    return _lib.Incr_fn_connors_rsi_ece379.make(ctx, ).collect(src, rsi_length, up_down_length, roc_length)
  }

class ConnorsRsiLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class ConnorsRsi {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_connors_rsi_ece379.make(this.ctx, );
    this.locals = ConnorsRsiLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, rsi_length, up_down_length, roc_length) {
    return this.inner.next(src, rsi_length, up_down_length, roc_length)
  }
}
    

export function coppockCurve(ctx, src, wma_length, long_roc_length, short_roc_length, ) {
    return _lib.Incr_fn_coppock_curve_f70598.make(ctx, ).collect(src, wma_length, long_roc_length, short_roc_length)
  }

class CoppockCurveLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class CoppockCurve {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_coppock_curve_f70598.make(this.ctx, );
    this.locals = CoppockCurveLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, wma_length, long_roc_length, short_roc_length) {
    return this.inner.next(src, wma_length, long_roc_length, short_roc_length)
  }
}
    

export function donchianChannel(ctx, src, length, ) {
    return _lib.Incr_fn_donchian_channel_c6e7c1.make(ctx, ).collect(src, length)
  }

class DonchianChannelLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class DonchianChannel {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_donchian_channel_c6e7c1.make(this.ctx, );
    this.locals = DonchianChannelLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function macd(ctx, src, short_length, long_length, ) {
    return _lib.Incr_fn_macd_08982e.make(ctx, ).collect(src, short_length, long_length)
  }

class MacdLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Macd {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_macd_08982e.make(this.ctx, );
    this.locals = MacdLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, short_length, long_length) {
    return this.inner.next(src, short_length, long_length)
  }
}
    

export function priceOscillator(ctx, src, short_length, long_length, ) {
    return _lib.Incr_fn_price_oscillator_588f58.make(ctx, ).collect(src, short_length, long_length)
  }

class PriceOscillatorLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class PriceOscillator {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_price_oscillator_588f58.make(this.ctx, );
    this.locals = PriceOscillatorLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, short_length, long_length) {
    return this.inner.next(src, short_length, long_length)
  }
}
    

export function relativeVigorIndex(ctx, length, ) {
    return _lib.Incr_fn_relative_vigor_index_bf4401.make(ctx, ).collect(length)
  }

class RelativeVigorIndexLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class RelativeVigorIndex {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_relative_vigor_index_bf4401.make(this.ctx, );
    this.locals = RelativeVigorIndexLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function relativeVolatilityIndex(ctx, src, length, ) {
    return _lib.Incr_fn_relative_volatility_index_73b11f.make(ctx, ).collect(src, length)
  }

class RelativeVolatilityIndexLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class RelativeVolatilityIndex {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_relative_volatility_index_73b11f.make(this.ctx, );
    this.locals = RelativeVolatilityIndexLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function stochasticRsi(ctx, src, stoch_length, rsi_length, k, d, ) {
    return _lib.Incr_fn_stochastic_rsi_839d1a.make(ctx, ).collect(src, stoch_length, rsi_length, k, d)
  }

class StochasticRsiLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class StochasticRsi {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_stochastic_rsi_839d1a.make(this.ctx, );
    this.locals = StochasticRsiLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, stoch_length, rsi_length, k, d) {
    return this.inner.next(src, stoch_length, rsi_length, k, d)
  }
}
    

export function ultimateOscillator(ctx, fast_length, medium_length, slow_length, ) {
    return _lib.Incr_fn_ultimate_oscillator_480aca.make(ctx, ).collect(fast_length, medium_length, slow_length)
  }

class UltimateOscillatorLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class UltimateOscillator {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_ultimate_oscillator_480aca.make(this.ctx, );
    this.locals = UltimateOscillatorLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(fast_length, medium_length, slow_length) {
    return this.inner.next(fast_length, medium_length, slow_length)
  }
}
    

export function volumeOscillator(ctx, short_length, long_length, ) {
    return _lib.Incr_fn_volume_oscillator_12d66d.make(ctx, ).collect(short_length, long_length)
  }

class VolumeOscillatorLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class VolumeOscillator {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_volume_oscillator_12d66d.make(this.ctx, );
    this.locals = VolumeOscillatorLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(short_length, long_length) {
    return this.inner.next(short_length, long_length)
  }
}
    

export function vortexIndicator(ctx, length, ) {
    return _lib.Incr_fn_vortex_indicator_aafc10.make(ctx, ).collect(length)
  }

class VortexIndicatorLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class VortexIndicator {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_vortex_indicator_aafc10.make(this.ctx, );
    this.locals = VortexIndicatorLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function williamsPctR(ctx, src, length, ) {
    return _lib.Incr_fn_williams_pct_r_723dbe.make(ctx, ).collect(src, length)
  }

class WilliamsPctRLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class WilliamsPctR {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_williams_pct_r_723dbe.make(this.ctx, );
    this.locals = WilliamsPctRLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function advanceDeclineRatio(ctx, length, ) {
    return _lib.Incr_fn_advance_decline_ratio_62137f.make(ctx, ).collect(length)
  }

class AdvanceDeclineRatioLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class AdvanceDeclineRatio {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_advance_decline_ratio_62137f.make(this.ctx, );
    this.locals = AdvanceDeclineRatioLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function detrendedPriceOscillator(ctx, length, centered, ) {
    return _lib.Incr_fn_detrended_price_oscillator_b3a31a.make(ctx, ).collect(length, centered)
  }

class DetrendedPriceOscillatorLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class DetrendedPriceOscillator {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_detrended_price_oscillator_b3a31a.make(this.ctx, );
    this.locals = DetrendedPriceOscillatorLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length, centered) {
    return this.inner.next(length, centered)
  }
}
    

export function bullBearPower(ctx, length, ) {
    return _lib.Incr_fn_bull_bear_power_27d2ce.make(ctx, ).collect(length)
  }

class BullBearPowerLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class BullBearPower {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_bull_bear_power_27d2ce.make(this.ctx, );
    this.locals = BullBearPowerLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function absolutePriceOscillator(ctx, src, fast_length, slow_length, ) {
    return _lib.Incr_fn_absolute_price_oscillator_50ba9c.make(ctx, ).collect(src, fast_length, slow_length)
  }

class AbsolutePriceOscillatorLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class AbsolutePriceOscillator {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_absolute_price_oscillator_50ba9c.make(this.ctx, );
    this.locals = AbsolutePriceOscillatorLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, fast_length, slow_length) {
    return this.inner.next(src, fast_length, slow_length)
  }
}
    

export function knowSureThing(ctx, src, roc_length1, roc_length2, roc_length3, roc_length4, sma_length1, sma_length2, sma_length3, sma_length4, sig_length, ) {
    return _lib.Incr_fn_know_sure_thing_26c284.make(ctx, ).collect(src, roc_length1, roc_length2, roc_length3, roc_length4, sma_length1, sma_length2, sma_length3, sma_length4, sig_length)
  }

class KnowSureThingLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class KnowSureThing {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_know_sure_thing_26c284.make(this.ctx, );
    this.locals = KnowSureThingLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, roc_length1, roc_length2, roc_length3, roc_length4, sma_length1, sma_length2, sma_length3, sma_length4, sig_length) {
    return this.inner.next(src, roc_length1, roc_length2, roc_length3, roc_length4, sma_length1, sma_length2, sma_length3, sma_length4, sig_length)
  }
}
    

export function momentum(ctx, src, length, ) {
    return _lib.Incr_fn_momentum_f6eb3d.make(ctx, ).collect(src, length)
  }

class MomentumLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Momentum {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_momentum_f6eb3d.make(this.ctx, );
    this.locals = MomentumLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function trix(ctx, src, length, ) {
    return _lib.Incr_fn_trix_a65be1.make(ctx, ).collect(src, length)
  }

class TrixLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Trix {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_trix_a65be1.make(this.ctx, );
    this.locals = TrixLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function trueStrengthIndex(ctx, src, long_length, short_length, ) {
    return _lib.Incr_fn_true_strength_index_20aed4.make(ctx, ).collect(src, long_length, short_length)
  }

class TrueStrengthIndexLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class TrueStrengthIndex {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_true_strength_index_20aed4.make(this.ctx, );
    this.locals = TrueStrengthIndexLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, long_length, short_length) {
    return this.inner.next(src, long_length, short_length)
  }
}
    

export function dema(ctx, src, length, ) {
    return _lib.Incr_fn_dema_19e27d.make(ctx, ).collect(src, length)
  }

class DemaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Dema {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_dema_19e27d.make(this.ctx, );
    this.locals = DemaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function fwma(ctx, src, length, ) {
    return _lib.Incr_fn_fwma_4933bd.make(ctx, ).collect(src, length)
  }

class FwmaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Fwma {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_fwma_4933bd.make(this.ctx, );
    this.locals = FwmaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function moneyFlowIndex(ctx, src, length, ) {
    return _lib.Incr_fn_money_flow_index_f4e8c6.make(ctx, ).collect(src, length)
  }

class MoneyFlowIndexLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class MoneyFlowIndex {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_money_flow_index_f4e8c6.make(this.ctx, );
    this.locals = MoneyFlowIndexLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function easeOfMovement(ctx, length, divisor, ) {
    return _lib.Incr_fn_ease_of_movement_4e4aa0.make(ctx, ).collect(length, divisor)
  }

class EaseOfMovementLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class EaseOfMovement {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_ease_of_movement_4e4aa0.make(this.ctx, );
    this.locals = EaseOfMovementLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length, divisor) {
    return this.inner.next(length, divisor)
  }
}
    

export function elderForceIndex(ctx, length, ) {
    return _lib.Incr_fn_elder_force_index_2dc1a9.make(ctx, ).collect(length)
  }

class ElderForceIndexLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class ElderForceIndex {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_elder_force_index_2dc1a9.make(this.ctx, );
    this.locals = ElderForceIndexLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(length) {
    return this.inner.next(length)
  }
}
    

export function tema(ctx, src, length, ) {
    return _lib.Incr_fn_tema_c148a3.make(ctx, ).collect(src, length)
  }

class TemaLocals {
    constructor(inner) {
        self.__inner = inner
    }

    

      
}

export class Tema {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_tema_c148a3.make(this.ctx, );
    this.locals = TemaLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next(src, length) {
    return this.inner.next(src, length)
  }
}
    

export function main(ctx, ) {
    return _lib.Incr_fn_main_c9fea8.make(ctx, ).collect()
  }

class MainLocals {
    constructor(inner) {
        self.__inner = inner
    }

    
}

export class Main {
  constructor(ctx, ) {
    this.ctx = ctx;
    this.inner = _lib.Incr_fn_main_c9fea8.make(this.ctx, );
    this.locals = MainLocals(this.inner)
  }

/* 
getCtx() {
    throw new Error("Not implemented yet");
  }
    */

  next() {
    return this.inner.next()
  }
}
    

       /* module.exports = {
            accdist,Accdist,cum,Cum,change,Change,barssince,Barssince,roc,Roc,crossover,Crossover,crossunder,Crossunder,cross,Cross,highestbars,Highestbars,lowestbars,Lowestbars,highest,Highest,lowest,Lowest,swma,Swma,sma,Sma,ema,Ema,rma,Rma,wma,Wma,lwma,Lwma,hma,Hma,vwma,Vwma,dev,Dev,tr,Tr,atr,Atr,rsi,Rsi,cci,Cci,stdev,Stdev,aroon,Aroon,supertrend,Supertrend,awesomeOscillator,AwesomeOscillator,balanceOfPower,BalanceOfPower,bollingerBandsPctB,BollingerBandsPctB,bollingerBandsWidth,BollingerBandsWidth,bollingerBands,BollingerBands,chaikinMoneyFlow,ChaikinMoneyFlow,chandeKrollStop,ChandeKrollStop,choppinessIndex,ChoppinessIndex,connorsRsi,ConnorsRsi,coppockCurve,CoppockCurve,donchianChannel,DonchianChannel,macd,Macd,priceOscillator,PriceOscillator,relativeVigorIndex,RelativeVigorIndex,relativeVolatilityIndex,RelativeVolatilityIndex,stochasticRsi,StochasticRsi,ultimateOscillator,UltimateOscillator,volumeOscillator,VolumeOscillator,vortexIndicator,VortexIndicator,williamsPctR,WilliamsPctR,advanceDeclineRatio,AdvanceDeclineRatio,detrendedPriceOscillator,DetrendedPriceOscillator,bullBearPower,BullBearPower,absolutePriceOscillator,AbsolutePriceOscillator,knowSureThing,KnowSureThing,momentum,Momentum,trix,Trix,trueStrengthIndex,TrueStrengthIndex,dema,Dema,fwma,Fwma,moneyFlowIndex,MoneyFlowIndex,easeOfMovement,EaseOfMovement,elderForceIndex,ElderForceIndex,tema,Tema,main,Main
        }*/
                