wickra/bindings/go/include/wickra.h

/* Wickra C ABI — generated by cbindgen. Do not edit by hand. */

#ifndef WICKRA_H
#define WICKRA_H

#pragma once

#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

typedef struct AbandonedBaby AbandonedBaby;

typedef struct Abcd Abcd;

typedef struct AbsoluteBreadthIndex AbsoluteBreadthIndex;

typedef struct AccelerationBands AccelerationBands;

typedef struct AcceleratorOscillator AcceleratorOscillator;

typedef struct AdOscillator AdOscillator;

typedef struct AdVolumeLine AdVolumeLine;

typedef struct AdaptiveCci AdaptiveCci;

typedef struct AdaptiveCycle AdaptiveCycle;

typedef struct AdaptiveLaguerreFilter AdaptiveLaguerreFilter;

typedef struct AdaptiveRsi AdaptiveRsi;

typedef struct Adl Adl;

typedef struct AdvanceBlock AdvanceBlock;

typedef struct AdvanceDecline AdvanceDecline;

typedef struct AdvanceDeclineRatio AdvanceDeclineRatio;

typedef struct Adx Adx;

typedef struct Adxr Adxr;

typedef struct Alligator Alligator;

typedef struct Alma Alma;

typedef struct Alpha Alpha;

typedef struct AmihudIlliquidity AmihudIlliquidity;

typedef struct AnchoredRsi AnchoredRsi;

typedef struct AnchoredVwap AnchoredVwap;

typedef struct AndrewsPitchfork AndrewsPitchfork;

typedef struct Apo Apo;

typedef struct Aroon Aroon;

typedef struct AroonOscillator AroonOscillator;

typedef struct Atr Atr;

typedef struct AtrBands AtrBands;

typedef struct AtrRatchet AtrRatchet;

typedef struct AtrTrailingStop AtrTrailingStop;

typedef struct AutoFib AutoFib;

typedef struct Autocorrelation Autocorrelation;

typedef struct AutocorrelationPeriodogram AutocorrelationPeriodogram;

typedef struct AverageDailyRange AverageDailyRange;

typedef struct AverageDrawdown AverageDrawdown;

typedef struct AvgPrice AvgPrice;

typedef struct AwesomeOscillator AwesomeOscillator;

typedef struct AwesomeOscillatorHistogram AwesomeOscillatorHistogram;

typedef struct BalanceOfPower BalanceOfPower;

typedef struct BandpassFilter BandpassFilter;

typedef struct Bat Bat;

typedef struct BeltHold BeltHold;

typedef struct Beta Beta;

typedef struct BetaNeutralSpread BetaNeutralSpread;

typedef struct BetterVolume BetterVolume;

typedef struct BipowerVariation BipowerVariation;

typedef struct BodySizePct BodySizePct;

typedef struct BollingerBands BollingerBands;

typedef struct BollingerBandwidth BollingerBandwidth;

typedef struct BomarBands BomarBands;

typedef struct BreadthThrust BreadthThrust;

typedef struct Breakaway Breakaway;

typedef struct BullishPercentIndex BullishPercentIndex;

typedef struct BurkeRatio BurkeRatio;

typedef struct Butterfly Butterfly;

typedef struct CalendarSpread CalendarSpread;

typedef struct CalmarRatio CalmarRatio;

typedef struct Camarilla Camarilla;

typedef struct CandleReader CandleReader;

typedef struct CandleVolume CandleVolume;

typedef struct Cci Cci;

typedef struct CenterOfGravity CenterOfGravity;

typedef struct CentralPivotRange CentralPivotRange;

typedef struct Cfo Cfo;

typedef struct ChaikinMoneyFlow ChaikinMoneyFlow;

typedef struct ChaikinOscillator ChaikinOscillator;

typedef struct ChaikinVolatility ChaikinVolatility;

typedef struct ChandeKrollStop ChandeKrollStop;

typedef struct ChandelierExit ChandelierExit;

typedef struct ChoppinessIndex ChoppinessIndex;

typedef struct ClassicPivots ClassicPivots;

typedef struct CloseVsOpen CloseVsOpen;

typedef struct ClosingMarubozu ClosingMarubozu;

typedef struct Cmo Cmo;

typedef struct CoefficientOfVariation CoefficientOfVariation;

typedef struct Cointegration Cointegration;

typedef struct CommonSenseRatio CommonSenseRatio;

typedef struct CompositeProfile CompositeProfile;

typedef struct ConcealingBabySwallow ConcealingBabySwallow;

typedef struct ConditionalValueAtRisk ConditionalValueAtRisk;

typedef struct ConnorsRsi ConnorsRsi;

typedef struct Coppock Coppock;

typedef struct CorrelationTrendIndicator CorrelationTrendIndicator;

typedef struct Counterattack Counterattack;

typedef struct Crab Crab;

typedef struct CumulativeVolumeDelta CumulativeVolumeDelta;

typedef struct CumulativeVolumeIndex CumulativeVolumeIndex;

typedef struct CupAndHandle CupAndHandle;

typedef struct CyberneticCycle CyberneticCycle;

typedef struct Cypher Cypher;

typedef struct DayOfWeekProfile DayOfWeekProfile;

typedef struct Decycler Decycler;

typedef struct DecyclerOscillator DecyclerOscillator;

typedef struct Dema Dema;

typedef struct DemandIndex DemandIndex;

typedef struct DemarkPivots DemarkPivots;

typedef struct DepthSlope DepthSlope;

typedef struct DerivativeOscillator DerivativeOscillator;

typedef struct DetrendedStdDev DetrendedStdDev;

typedef struct DisparityIndex DisparityIndex;

typedef struct DistanceSsd DistanceSsd;

typedef struct Doji Doji;

typedef struct DojiStar DojiStar;

typedef struct DollarBars DollarBars;

typedef struct Donchian Donchian;

typedef struct DonchianStop DonchianStop;

typedef struct DoubleBollinger DoubleBollinger;

typedef struct DoubleTopBottom DoubleTopBottom;

typedef struct DownsideGapThreeMethods DownsideGapThreeMethods;

typedef struct Dpo Dpo;

typedef struct DragonflyDoji DragonflyDoji;

typedef struct DrawdownDuration DrawdownDuration;

typedef struct DumplingTop DumplingTop;

typedef struct Dx Dx;

typedef struct DynamicMomentumIndex DynamicMomentumIndex;

typedef struct EaseOfMovement EaseOfMovement;

typedef struct EffectiveSpread EffectiveSpread;

typedef struct EhlersStochastic EhlersStochastic;

typedef struct Ehma Ehma;

typedef struct ElderImpulse ElderImpulse;

typedef struct ElderRay ElderRay;

typedef struct ElderSafeZone ElderSafeZone;

typedef struct Ema Ema;

typedef struct EmpiricalModeDecomposition EmpiricalModeDecomposition;

typedef struct Engulfing Engulfing;

typedef struct Equivolume Equivolume;

typedef struct EstimatedLeverageRatio EstimatedLeverageRatio;

typedef struct EvenBetterSinewave EvenBetterSinewave;

typedef struct EveningDojiStar EveningDojiStar;

typedef struct Evwma Evwma;

typedef struct EwmaVolatility EwmaVolatility;

typedef struct Expectancy Expectancy;

typedef struct FallingThreeMethods FallingThreeMethods;

typedef struct Fama Fama;

typedef struct FibArcs FibArcs;

typedef struct FibChannel FibChannel;

typedef struct FibConfluence FibConfluence;

typedef struct FibExtension FibExtension;

typedef struct FibFan FibFan;

typedef struct FibProjection FibProjection;

typedef struct FibRetracement FibRetracement;

typedef struct FibTimeZones FibTimeZones;

typedef struct FibonacciPivots FibonacciPivots;

typedef struct FisherRsi FisherRsi;

typedef struct FisherTransform FisherTransform;

typedef struct FlagPennant FlagPennant;

typedef struct Footprint Footprint;

typedef struct ForceIndex ForceIndex;

typedef struct FractalChaosBands FractalChaosBands;

typedef struct Frama Frama;

typedef struct FryPanBottom FryPanBottom;

typedef struct FundingBasis FundingBasis;

typedef struct FundingImpliedApr FundingImpliedApr;

typedef struct FundingRate FundingRate;

typedef struct FundingRateMean FundingRateMean;

typedef struct FundingRateZScore FundingRateZScore;

typedef struct GainLossRatio GainLossRatio;

typedef struct GainToPainRatio GainToPainRatio;

typedef struct GapSideBySideWhite GapSideBySideWhite;

typedef struct Garch11 Garch11;

typedef struct GarmanKlassVolatility GarmanKlassVolatility;

typedef struct Gartley Gartley;

typedef struct GatorOscillator GatorOscillator;

typedef struct GeneralizedDema GeneralizedDema;

typedef struct GeometricMa GeometricMa;

typedef struct GoldenPocket GoldenPocket;

typedef struct GrangerCausality GrangerCausality;

typedef struct GravestoneDoji GravestoneDoji;

typedef struct Hammer Hammer;

typedef struct HangingMan HangingMan;

typedef struct Harami Harami;

typedef struct HaramiCross HaramiCross;

typedef struct HasbrouckInformationShare HasbrouckInformationShare;

typedef struct HeadAndShoulders HeadAndShoulders;

typedef struct HeikinAshi HeikinAshi;

typedef struct HeikinAshiOscillator HeikinAshiOscillator;

typedef struct HiLoActivator HiLoActivator;

typedef struct HighLowIndex HighLowIndex;

typedef struct HighLowRange HighLowRange;

typedef struct HighLowVolumeNodes HighLowVolumeNodes;

typedef struct HighWave HighWave;

typedef struct HighpassFilter HighpassFilter;

typedef struct Hikkake Hikkake;

typedef struct HikkakeModified HikkakeModified;

typedef struct HilbertDominantCycle HilbertDominantCycle;

typedef struct HistoricalVolatility HistoricalVolatility;

typedef struct Hma Hma;

typedef struct HoltWinters HoltWinters;

typedef struct HomingPigeon HomingPigeon;

typedef struct HtDcPhase HtDcPhase;

typedef struct HtPhasor HtPhasor;

typedef struct HtTrendMode HtTrendMode;

typedef struct HurstChannel HurstChannel;

typedef struct HurstExponent HurstExponent;

typedef struct Ichimoku Ichimoku;

typedef struct IdenticalThreeCrows IdenticalThreeCrows;

typedef struct ImbalanceBars ImbalanceBars;

typedef struct InNeck InNeck;

typedef struct Inertia Inertia;

typedef struct InformationRatio InformationRatio;

typedef struct InitialBalance InitialBalance;

typedef struct InstantaneousTrendline InstantaneousTrendline;

typedef struct IntradayIntensity IntradayIntensity;

typedef struct IntradayMomentumIndex IntradayMomentumIndex;

typedef struct IntradayVolatilityProfile IntradayVolatilityProfile;

typedef struct InverseFisherTransform InverseFisherTransform;

typedef struct InvertedHammer InvertedHammer;

typedef struct JarqueBera JarqueBera;

typedef struct Jma Jma;

typedef struct JumpIndicator JumpIndicator;

typedef struct KRatio KRatio;

typedef struct KagiBars KagiBars;

typedef struct KalmanHedgeRatio KalmanHedgeRatio;

typedef struct Kama Kama;

typedef struct KaseDevStop KaseDevStop;

typedef struct KasePermissionStochastic KasePermissionStochastic;

typedef struct KellyCriterion KellyCriterion;

typedef struct Keltner Keltner;

typedef struct KendallTau KendallTau;

typedef struct Kicking Kicking;

typedef struct KickingByLength KickingByLength;

typedef struct Kst Kst;

typedef struct Kurtosis Kurtosis;

typedef struct Kvo Kvo;

typedef struct KylesLambda KylesLambda;

typedef struct LadderBottom LadderBottom;

typedef struct LaguerreRsi LaguerreRsi;

typedef struct LeadLagCrossCorrelation LeadLagCrossCorrelation;

typedef struct LinRegAngle LinRegAngle;

typedef struct LinRegChannel LinRegChannel;

typedef struct LinRegIntercept LinRegIntercept;

typedef struct LinRegSlope LinRegSlope;

typedef struct LinearRegression LinearRegression;

typedef struct LiquidationFeatures LiquidationFeatures;

typedef struct LogReturn LogReturn;

typedef struct LongLeggedDoji LongLeggedDoji;

typedef struct LongLine LongLine;

typedef struct LongShortRatio LongShortRatio;

typedef struct M2Measure M2Measure;

typedef struct MaEnvelope MaEnvelope;

typedef struct MacdExt MacdExt;

typedef struct MacdFix MacdFix;

typedef struct MacdHistogram MacdHistogram;

typedef struct MacdIndicator MacdIndicator;

typedef struct Mama Mama;

typedef struct MarketFacilitationIndex MarketFacilitationIndex;

typedef struct MartinRatio MartinRatio;

typedef struct Marubozu Marubozu;

typedef struct MassIndex MassIndex;

typedef struct MatHold MatHold;

typedef struct MatchingLow MatchingLow;

typedef struct MaxDrawdown MaxDrawdown;

typedef struct McClellanOscillator McClellanOscillator;

typedef struct McClellanSummationIndex McClellanSummationIndex;

typedef struct McGinleyDynamic McGinleyDynamic;

typedef struct MedianAbsoluteDeviation MedianAbsoluteDeviation;

typedef struct MedianChannel MedianChannel;

typedef struct MedianMa MedianMa;

typedef struct MedianPrice MedianPrice;

typedef struct Mfi Mfi;

typedef struct Microprice Microprice;

typedef struct MidPoint MidPoint;

typedef struct MidPrice MidPrice;

typedef struct MinusDi MinusDi;

typedef struct MinusDm MinusDm;

typedef struct ModifiedMaStop ModifiedMaStop;

typedef struct Mom Mom;

typedef struct MorningDojiStar MorningDojiStar;

typedef struct MorningEveningStar MorningEveningStar;

typedef struct MurreyMathLines MurreyMathLines;

typedef struct NakedPoc NakedPoc;

typedef struct Natr Natr;

typedef struct NewHighsNewLows NewHighsNewLows;

typedef struct NewPriceLines NewPriceLines;

typedef struct Nrtr Nrtr;

typedef struct Nvi Nvi;

typedef struct OIPriceDivergence OIPriceDivergence;

typedef struct OIWeighted OIWeighted;

typedef struct Obv Obv;

typedef struct OiToVolumeRatio OiToVolumeRatio;

typedef struct OmegaRatio OmegaRatio;

typedef struct OnNeck OnNeck;

typedef struct OpenInterestDelta OpenInterestDelta;

typedef struct OpenInterestMomentum OpenInterestMomentum;

typedef struct OpeningMarubozu OpeningMarubozu;

typedef struct OpeningRange OpeningRange;

typedef struct OrderBookImbalanceFull OrderBookImbalanceFull;

typedef struct OrderBookImbalanceTop1 OrderBookImbalanceTop1;

typedef struct OrderBookImbalanceTopN OrderBookImbalanceTopN;

typedef struct OrderFlowImbalance OrderFlowImbalance;

typedef struct OuHalfLife OuHalfLife;

typedef struct OvernightGap OvernightGap;

typedef struct OvernightIntradayReturn OvernightIntradayReturn;

typedef struct PainIndex PainIndex;

typedef struct PairSpreadZScore PairSpreadZScore;

typedef struct PairwiseBeta PairwiseBeta;

typedef struct ParkinsonVolatility ParkinsonVolatility;

typedef struct PearsonCorrelation PearsonCorrelation;

typedef struct PercentAboveMa PercentAboveMa;

typedef struct PercentB PercentB;

typedef struct PercentageTrailingStop PercentageTrailingStop;

typedef struct PerpetualPremiumIndex PerpetualPremiumIndex;

typedef struct Pgo Pgo;

typedef struct PiercingDarkCloud PiercingDarkCloud;

typedef struct Pin Pin;

typedef struct PivotReversal PivotReversal;

typedef struct PlusDi PlusDi;

typedef struct PlusDm PlusDm;

typedef struct Pmo Pmo;

typedef struct PointAndFigureBars PointAndFigureBars;

typedef struct PolarizedFractalEfficiency PolarizedFractalEfficiency;

typedef struct Ppo Ppo;

typedef struct PpoHistogram PpoHistogram;

typedef struct ProfileShape ProfileShape;

typedef struct ProfitFactor ProfitFactor;

typedef struct ProjectionBands ProjectionBands;

typedef struct ProjectionOscillator ProjectionOscillator;

typedef struct Psar Psar;

typedef struct Pvi Pvi;

typedef struct Qqe Qqe;

typedef struct Qstick Qstick;

typedef struct QuartileBands QuartileBands;

typedef struct QuotedSpread QuotedSpread;

typedef struct RSquared RSquared;

typedef struct RangeBars RangeBars;

typedef struct RealizedSpread RealizedSpread;

typedef struct RealizedVolatility RealizedVolatility;

typedef struct RecoveryFactor RecoveryFactor;

typedef struct RectangleRange RectangleRange;

typedef struct Reflex Reflex;

typedef struct RegimeLabel RegimeLabel;

typedef struct RelativeStrengthAB RelativeStrengthAB;

typedef struct RenkoBars RenkoBars;

typedef struct RenkoTrailingStop RenkoTrailingStop;

typedef struct Resampler Resampler;

typedef struct RickshawMan RickshawMan;

typedef struct RisingThreeMethods RisingThreeMethods;

typedef struct Rmi Rmi;

typedef struct Roc Roc;

typedef struct Rocp Rocp;

typedef struct Rocr Rocr;

typedef struct Rocr100 Rocr100;

typedef struct RogersSatchellVolatility RogersSatchellVolatility;

typedef struct RollMeasure RollMeasure;

typedef struct RollingCorrelation RollingCorrelation;

typedef struct RollingCovariance RollingCovariance;

typedef struct RollingIqr RollingIqr;

typedef struct RollingMinMaxScaler RollingMinMaxScaler;

typedef struct RollingPercentileRank RollingPercentileRank;

typedef struct RollingQuantile RollingQuantile;

typedef struct RollingVwap RollingVwap;

typedef struct RoofingFilter RoofingFilter;

typedef struct Rsi Rsi;

typedef struct Rsx Rsx;

typedef struct RunBars RunBars;

typedef struct Rvi Rvi;

typedef struct RviVolatility RviVolatility;

typedef struct Rwi Rwi;

typedef struct SampleEntropy SampleEntropy;

typedef struct SarExt SarExt;

typedef struct SeasonalZScore SeasonalZScore;

typedef struct SeparatingLines SeparatingLines;

typedef struct SessionHighLow SessionHighLow;

typedef struct SessionRange SessionRange;

typedef struct SessionVwap SessionVwap;

typedef struct ShannonEntropy ShannonEntropy;

typedef struct Shark Shark;

typedef struct SharpeRatio SharpeRatio;

typedef struct ShootingStar ShootingStar;

typedef struct ShortLine ShortLine;

typedef struct SignedVolume SignedVolume;

typedef struct SineWave SineWave;

typedef struct SineWeightedMa SineWeightedMa;

typedef struct SinglePrints SinglePrints;

typedef struct Skewness Skewness;

typedef struct Sma Sma;

typedef struct Smi Smi;

typedef struct Smma Smma;

typedef struct SmoothedHeikinAshi SmoothedHeikinAshi;

typedef struct SortinoRatio SortinoRatio;

typedef struct SpearmanCorrelation SpearmanCorrelation;

typedef struct SpinningTop SpinningTop;

typedef struct SpreadAr1Coefficient SpreadAr1Coefficient;

typedef struct SpreadBollingerBands SpreadBollingerBands;

typedef struct SpreadHurst SpreadHurst;

typedef struct StalledPattern StalledPattern;

typedef struct StandardError StandardError;

typedef struct StandardErrorBands StandardErrorBands;

typedef struct StarcBands StarcBands;

typedef struct Stc Stc;

typedef struct StdDev StdDev;

typedef struct StepTrailingStop StepTrailingStop;

typedef struct SterlingRatio SterlingRatio;

typedef struct StickSandwich StickSandwich;

typedef struct StochRsi StochRsi;

typedef struct Stochastic Stochastic;

typedef struct StochasticCci StochasticCci;

typedef struct SuperSmoother SuperSmoother;

typedef struct SuperTrend SuperTrend;

typedef struct T3 T3;

typedef struct TailRatio TailRatio;

typedef struct TakerBuySellRatio TakerBuySellRatio;

typedef struct Takuri Takuri;

typedef struct TasukiGap TasukiGap;

typedef struct TdCamouflage TdCamouflage;

typedef struct TdClop TdClop;

typedef struct TdClopwin TdClopwin;

typedef struct TdCombo TdCombo;

typedef struct TdCountdown TdCountdown;

typedef struct TdDWave TdDWave;

typedef struct TdDeMarker TdDeMarker;

typedef struct TdDifferential TdDifferential;

typedef struct TdLines TdLines;

typedef struct TdMovingAverage TdMovingAverage;

typedef struct TdOpen TdOpen;

typedef struct TdPressure TdPressure;

typedef struct TdPropulsion TdPropulsion;

typedef struct TdRangeProjection TdRangeProjection;

typedef struct TdRei TdRei;

typedef struct TdRiskLevel TdRiskLevel;

typedef struct TdSequential TdSequential;

typedef struct TdSetup TdSetup;

typedef struct TdTrap TdTrap;

typedef struct Tema Tema;

typedef struct TermStructureBasis TermStructureBasis;

typedef struct ThreeDrives ThreeDrives;

typedef struct ThreeInside ThreeInside;

typedef struct ThreeLineBreak ThreeLineBreak;

typedef struct ThreeLineBreakBars ThreeLineBreakBars;

typedef struct ThreeLineStrike ThreeLineStrike;

typedef struct ThreeOutside ThreeOutside;

typedef struct ThreeSoldiersOrCrows ThreeSoldiersOrCrows;

typedef struct ThreeStarsInSouth ThreeStarsInSouth;

typedef struct Thrusting Thrusting;

typedef struct TickAggregator TickAggregator;

typedef struct TickBars TickBars;

typedef struct TickIndex TickIndex;

typedef struct Tii Tii;

typedef struct TimeBasedStop TimeBasedStop;

typedef struct TimeOfDayReturnProfile TimeOfDayReturnProfile;

typedef struct TowerTopBottom TowerTopBottom;

typedef struct TpoProfile TpoProfile;

typedef struct TradeImbalance TradeImbalance;

typedef struct TradeSignAutocorrelation TradeSignAutocorrelation;

typedef struct TradeVolumeIndex TradeVolumeIndex;

typedef struct TrendLabel TrendLabel;

typedef struct TrendStrengthIndex TrendStrengthIndex;

typedef struct Trendflex Trendflex;

typedef struct TreynorRatio TreynorRatio;

typedef struct Triangle Triangle;

typedef struct Trima Trima;

typedef struct Trin Trin;

typedef struct TripleTopBottom TripleTopBottom;

typedef struct Tristar Tristar;

typedef struct Trix Trix;

typedef struct TrueRange TrueRange;

typedef struct Tsf Tsf;

typedef struct TsfOscillator TsfOscillator;

typedef struct Tsi Tsi;

typedef struct Tsv Tsv;

typedef struct TtmSqueeze TtmSqueeze;

typedef struct TtmTrend TtmTrend;

typedef struct TurnOfMonth TurnOfMonth;

typedef struct Tweezer Tweezer;

typedef struct TwiggsMoneyFlow TwiggsMoneyFlow;

typedef struct TwoCrows TwoCrows;

typedef struct TypicalPrice TypicalPrice;

typedef struct UlcerIndex UlcerIndex;

typedef struct UltimateOscillator UltimateOscillator;

typedef struct UniqueThreeRiver UniqueThreeRiver;

typedef struct UniversalOscillator UniversalOscillator;

typedef struct UpDownVolumeRatio UpDownVolumeRatio;

typedef struct UpsideGapThreeMethods UpsideGapThreeMethods;

typedef struct UpsideGapTwoCrows UpsideGapTwoCrows;

typedef struct UpsidePotentialRatio UpsidePotentialRatio;

typedef struct ValueArea ValueArea;

typedef struct ValueAtRisk ValueAtRisk;

typedef struct Variance Variance;

typedef struct VarianceRatio VarianceRatio;

typedef struct VerticalHorizontalFilter VerticalHorizontalFilter;

typedef struct Vidya Vidya;

typedef struct VolatilityCone VolatilityCone;

typedef struct VolatilityOfVolatility VolatilityOfVolatility;

typedef struct VolatilityRatio VolatilityRatio;

typedef struct VoltyStop VoltyStop;

typedef struct VolumeBars VolumeBars;

typedef struct VolumeByTimeProfile VolumeByTimeProfile;

typedef struct VolumeOscillator VolumeOscillator;

typedef struct VolumePriceTrend VolumePriceTrend;

typedef struct VolumeProfile VolumeProfile;

typedef struct VolumeRsi VolumeRsi;

typedef struct VolumeWeightedMacd VolumeWeightedMacd;

typedef struct VolumeWeightedSr VolumeWeightedSr;

typedef struct Vortex Vortex;

typedef struct Vpin Vpin;

typedef struct Vwap Vwap;

typedef struct VwapStdDevBands VwapStdDevBands;

typedef struct Vwma Vwma;

typedef struct Vzo Vzo;

typedef struct Wad Wad;

typedef struct WavePm WavePm;

typedef struct WaveTrend WaveTrend;

typedef struct Wedge Wedge;

typedef struct WeightedClose WeightedClose;

typedef struct WickRatio WickRatio;

typedef struct WilliamsFractals WilliamsFractals;

typedef struct WilliamsR WilliamsR;

typedef struct WinRate WinRate;

typedef struct Wma Wma;

typedef struct WoodiePivots WoodiePivots;

typedef struct YangZhangVolatility YangZhangVolatility;

typedef struct YoyoExit YoyoExit;

typedef struct ZScore ZScore;

typedef struct ZeroLagMacd ZeroLagMacd;

typedef struct ZigZag ZigZag;

typedef struct Zlema Zlema;

typedef struct WickraAccelerationBandsOutput {
    double upper;
    double middle;
    double lower;
} WickraAccelerationBandsOutput;

typedef struct WickraAdxOutput {
    double plus_di;
    double minus_di;
    double adx;
} WickraAdxOutput;

typedef struct WickraAlligatorOutput {
    double jaw;
    double teeth;
    double lips;
} WickraAlligatorOutput;

typedef struct WickraAndrewsPitchforkOutput {
    double median;
    double upper;
    double lower;
} WickraAndrewsPitchforkOutput;

typedef struct WickraAroonOutput {
    double up;
    double down;
} WickraAroonOutput;

typedef struct WickraAtrBandsOutput {
    double upper;
    double middle;
    double lower;
} WickraAtrBandsOutput;

typedef struct WickraAtrRatchetOutput {
    double value;
    double direction;
} WickraAtrRatchetOutput;

typedef struct WickraAutoFibOutput {
    double level_0;
    double level_236;
    double level_382;
    double level_500;
    double level_618;
    double level_786;
    double level_1000;
} WickraAutoFibOutput;

typedef struct WickraBollingerOutput {
    double upper;
    double middle;
    double lower;
    double stddev;
} WickraBollingerOutput;

typedef struct WickraBomarBandsOutput {
    double upper;
    double middle;
    double lower;
} WickraBomarBandsOutput;

typedef struct WickraCamarillaPivotsOutput {
    double pp;
    double r1;
    double r2;
    double r3;
    double r4;
    double s1;
    double s2;
    double s3;
    double s4;
} WickraCamarillaPivotsOutput;

typedef struct WickraCandleVolumeOutput {
    double body;
    double width;
} WickraCandleVolumeOutput;

typedef struct WickraCentralPivotRangeOutput {
    double pivot;
    double tc;
    double bc;
} WickraCentralPivotRangeOutput;

typedef struct WickraChandeKrollStopOutput {
    double stop_long;
    double stop_short;
} WickraChandeKrollStopOutput;

typedef struct WickraChandelierExitOutput {
    double long_stop;
    double short_stop;
} WickraChandelierExitOutput;

typedef struct WickraClassicPivotsOutput {
    double pp;
    double r1;
    double r2;
    double r3;
    double s1;
    double s2;
    double s3;
} WickraClassicPivotsOutput;

typedef struct WickraCointegrationOutput {
    double hedge_ratio;
    double spread;
    double adf_stat;
} WickraCointegrationOutput;

typedef struct WickraCompositeProfileOutput {
    double poc;
    double vah;
    double val;
} WickraCompositeProfileOutput;

typedef struct WickraDemarkPivotsOutput {
    double pp;
    double r1;
    double s1;
} WickraDemarkPivotsOutput;

typedef struct WickraDonchianOutput {
    double upper;
    double middle;
    double lower;
} WickraDonchianOutput;

typedef struct WickraDonchianStopOutput {
    double stop_long;
    double stop_short;
} WickraDonchianStopOutput;

typedef struct WickraDoubleBollingerOutput {
    double upper_outer;
    double upper_inner;
    double middle;
    double lower_inner;
    double lower_outer;
} WickraDoubleBollingerOutput;

typedef struct WickraElderRayOutput {
    double bull_power;
    double bear_power;
} WickraElderRayOutput;

typedef struct WickraElderSafeZoneOutput {
    double value;
    double direction;
} WickraElderSafeZoneOutput;

typedef struct WickraEquivolumeOutput {
    double height;
    double width;
} WickraEquivolumeOutput;

typedef struct WickraFibArcsOutput {
    double arc_382;
    double arc_500;
    double arc_618;
} WickraFibArcsOutput;

typedef struct WickraFibChannelOutput {
    double base;
    double level_618;
    double level_1000;
    double level_1618;
} WickraFibChannelOutput;

typedef struct WickraFibConfluenceOutput {
    double price;
    double strength;
} WickraFibConfluenceOutput;

typedef struct WickraFibExtensionOutput {
    double level_1272;
    double level_1414;
    double level_1618;
    double level_2000;
    double level_2618;
} WickraFibExtensionOutput;

typedef struct WickraFibFanOutput {
    double fan_382;
    double fan_500;
    double fan_618;
} WickraFibFanOutput;

typedef struct WickraFibProjectionOutput {
    double level_618;
    double level_1000;
    double level_1618;
    double level_2618;
} WickraFibProjectionOutput;

typedef struct WickraFibRetracementOutput {
    double level_0;
    double level_236;
    double level_382;
    double level_500;
    double level_618;
    double level_786;
    double level_1000;
} WickraFibRetracementOutput;

typedef struct WickraFibTimeZonesOutput {
    double on_zone;
    double bars_to_next;
} WickraFibTimeZonesOutput;

typedef struct WickraFibonacciPivotsOutput {
    double pp;
    double r1;
    double r2;
    double r3;
    double s1;
    double s2;
    double s3;
} WickraFibonacciPivotsOutput;

typedef struct WickraFractalChaosBandsOutput {
    double upper;
    double lower;
} WickraFractalChaosBandsOutput;

typedef struct WickraGatorOscillatorOutput {
    double upper;
    double lower;
} WickraGatorOscillatorOutput;

typedef struct WickraGoldenPocketOutput {
    double low;
    double mid;
    double high;
} WickraGoldenPocketOutput;

typedef struct WickraHeikinAshiOutput {
    double open;
    double high;
    double low;
    double close;
} WickraHeikinAshiOutput;

typedef struct WickraHighLowVolumeNodesOutput {
    double hvn;
    double lvn;
} WickraHighLowVolumeNodesOutput;

typedef struct WickraHtPhasorOutput {
    double inphase;
    double quadrature;
} WickraHtPhasorOutput;

typedef struct WickraHurstChannelOutput {
    double upper;
    double middle;
    double lower;
} WickraHurstChannelOutput;

typedef struct WickraIchimokuOutput {
    double tenkan;
    double kijun;
    double senkou_a;
    double senkou_b;
    double chikou;
} WickraIchimokuOutput;

typedef struct WickraInitialBalanceOutput {
    double high;
    double low;
} WickraInitialBalanceOutput;

typedef struct WickraKalmanHedgeRatioOutput {
    double hedge_ratio;
    double intercept;
    double spread;
} WickraKalmanHedgeRatioOutput;

typedef struct WickraKaseDevStopOutput {
    double value;
    double direction;
} WickraKaseDevStopOutput;

typedef struct WickraKasePermissionStochasticOutput {
    double fast;
    double slow;
} WickraKasePermissionStochasticOutput;

typedef struct WickraKeltnerOutput {
    double upper;
    double middle;
    double lower;
} WickraKeltnerOutput;

typedef struct WickraKstOutput {
    double kst;
    double signal;
} WickraKstOutput;

typedef struct WickraLeadLagCrossCorrelationOutput {
    int64_t lag;
    double correlation;
} WickraLeadLagCrossCorrelationOutput;

typedef struct WickraLinRegChannelOutput {
    double upper;
    double middle;
    double lower;
} WickraLinRegChannelOutput;

typedef struct WickraLiquidationFeaturesOutput {
    double long_;
    double short_;
    double net;
    double total;
    double imbalance;
} WickraLiquidationFeaturesOutput;

typedef struct WickraMaEnvelopeOutput {
    double upper;
    double middle;
    double lower;
} WickraMaEnvelopeOutput;

typedef struct WickraMacdOutput {
    double macd;
    double signal;
    double histogram;
} WickraMacdOutput;

typedef struct WickraMamaOutput {
    double mama;
    double fama;
} WickraMamaOutput;

typedef struct WickraMedianChannelOutput {
    double upper;
    double middle;
    double lower;
} WickraMedianChannelOutput;

typedef struct WickraModifiedMaStopOutput {
    double value;
    double direction;
} WickraModifiedMaStopOutput;

typedef struct WickraMurreyMathLinesOutput {
    double mm8_8;
    double mm7_8;
    double mm6_8;
    double mm5_8;
    double mm4_8;
    double mm3_8;
    double mm2_8;
    double mm1_8;
    double mm0_8;
} WickraMurreyMathLinesOutput;

typedef struct WickraNrtrOutput {
    double value;
    double direction;
} WickraNrtrOutput;

typedef struct WickraOpeningRangeOutput {
    double high;
    double low;
    double breakout_distance;
} WickraOpeningRangeOutput;

typedef struct WickraOvernightIntradayReturnOutput {
    double overnight;
    double intraday;
} WickraOvernightIntradayReturnOutput;

typedef struct WickraProjectionBandsOutput {
    double upper;
    double middle;
    double lower;
} WickraProjectionBandsOutput;

typedef struct WickraQqeOutput {
    double rsi_ma;
    double trailing_line;
} WickraQqeOutput;

typedef struct WickraQuartileBandsOutput {
    double upper;
    double middle;
    double lower;
} WickraQuartileBandsOutput;

typedef struct WickraRelativeStrengthOutput {
    double ratio;
    double ratio_ma;
    double ratio_rsi;
} WickraRelativeStrengthOutput;

typedef struct WickraRwiOutput {
    double high;
    double low;
} WickraRwiOutput;

typedef struct WickraSessionHighLowOutput {
    double high;
    double low;
} WickraSessionHighLowOutput;

typedef struct WickraSessionRangeOutput {
    double asia;
    double eu;
    double us;
} WickraSessionRangeOutput;

typedef struct WickraSmoothedHeikinAshiOutput {
    double open;
    double high;
    double low;
    double close;
} WickraSmoothedHeikinAshiOutput;

typedef struct WickraSpreadBollingerBandsOutput {
    double middle;
    double upper;
    double lower;
    double percent_b;
} WickraSpreadBollingerBandsOutput;

typedef struct WickraStandardErrorBandsOutput {
    double upper;
    double middle;
    double lower;
} WickraStandardErrorBandsOutput;

typedef struct WickraStarcBandsOutput {
    double upper;
    double middle;
    double lower;
} WickraStarcBandsOutput;

typedef struct WickraStochasticOutput {
    double k;
    double d;
} WickraStochasticOutput;

typedef struct WickraSuperTrendOutput {
    double value;
    double direction;
} WickraSuperTrendOutput;

typedef struct WickraTdLinesOutput {
    double resistance;
    double support;
} WickraTdLinesOutput;

typedef struct WickraTdMovingAverageOutput {
    double st1;
    double st2;
} WickraTdMovingAverageOutput;

typedef struct WickraTdRangeProjectionOutput {
    double high;
    double low;
} WickraTdRangeProjectionOutput;

typedef struct WickraTdRiskLevelOutput {
    double buy_risk;
    double sell_risk;
} WickraTdRiskLevelOutput;

typedef struct WickraTdSequentialOutput {
    double setup;
    double countdown;
    double direction;
} WickraTdSequentialOutput;

typedef struct WickraTtmSqueezeOutput {
    double squeeze;
    double momentum;
} WickraTtmSqueezeOutput;

typedef struct WickraValueAreaOutput {
    double poc;
    double vah;
    double val;
} WickraValueAreaOutput;

typedef struct WickraVolatilityConeOutput {
    double current;
    double min;
    double median;
    double max;
    double percentile;
} WickraVolatilityConeOutput;

typedef struct WickraVolumeWeightedMacdOutput {
    double macd;
    double signal;
    double histogram;
} WickraVolumeWeightedMacdOutput;

typedef struct WickraVolumeWeightedSrOutput {
    double support;
    double resistance;
} WickraVolumeWeightedSrOutput;

typedef struct WickraVortexOutput {
    double plus;
    double minus;
} WickraVortexOutput;

typedef struct WickraVwapStdDevBandsOutput {
    double upper;
    double middle;
    double lower;
    double stddev;
} WickraVwapStdDevBandsOutput;

typedef struct WickraWaveTrendOutput {
    double wt1;
    double wt2;
} WickraWaveTrendOutput;

typedef struct WickraWilliamsFractalsOutput {
    double up;
    double down;
} WickraWilliamsFractalsOutput;

typedef struct WickraWoodiePivotsOutput {
    double pp;
    double r1;
    double r2;
    double s1;
    double s2;
} WickraWoodiePivotsOutput;

typedef struct WickraZeroLagMacdOutput {
    double macd;
    double signal;
    double histogram;
} WickraZeroLagMacdOutput;

typedef struct WickraZigZagOutput {
    double swing;
    double direction;
} WickraZigZagOutput;

typedef struct WickraTpoProfileOutputScalars {
    double price_low;
    double price_high;
} WickraTpoProfileOutputScalars;

typedef struct WickraVolumeProfileOutputScalars {
    double price_low;
    double price_high;
} WickraVolumeProfileOutputScalars;

typedef struct WickraDollarBar {
    double open;
    double high;
    double low;
    double close;
    double volume;
    double dollar;
} WickraDollarBar;

typedef struct WickraImbalanceBar {
    double open;
    double high;
    double low;
    double close;
    double imbalance;
    int8_t direction;
} WickraImbalanceBar;

typedef struct WickraKagiBar {
    double start;
    double end;
    int8_t direction;
} WickraKagiBar;

typedef struct WickraPnfColumn {
    int8_t direction;
    double high;
    double low;
} WickraPnfColumn;

typedef struct WickraRangeBar {
    double open;
    double close;
    int8_t direction;
} WickraRangeBar;

typedef struct WickraRenkoBrick {
    double open;
    double close;
    int8_t direction;
} WickraRenkoBrick;

typedef struct WickraRunBar {
    double open;
    double high;
    double low;
    double close;
    uintptr_t length;
    int8_t direction;
} WickraRunBar;

typedef struct WickraLineBreakBar {
    double open;
    double close;
    int8_t direction;
} WickraLineBreakBar;

typedef struct WickraTickBar {
    double open;
    double high;
    double low;
    double close;
    double volume;
} WickraTickBar;

typedef struct WickraVolumeBar {
    double open;
    double high;
    double low;
    double close;
    double volume;
} WickraVolumeBar;

typedef struct WickraFootprintLevel {
    double price;
    double bid_vol;
    double ask_vol;
} WickraFootprintLevel;

typedef struct WickraCandle {
    double open;
    double high;
    double low;
    double close;
    double volume;
    int64_t timestamp;
} WickraCandle;

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

struct AdaptiveCycle *wickra_adaptive_cycle_new(void);

double wickra_adaptive_cycle_update(struct AdaptiveCycle *handle, double value);

void wickra_adaptive_cycle_batch(struct AdaptiveCycle *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_adaptive_cycle_warmup_period(struct AdaptiveCycle *handle);

bool wickra_adaptive_cycle_is_ready(struct AdaptiveCycle *handle);

const char *wickra_adaptive_cycle_name(struct AdaptiveCycle *handle);

void wickra_adaptive_cycle_reset(struct AdaptiveCycle *handle);

void wickra_adaptive_cycle_free(struct AdaptiveCycle *handle);

struct AdaptiveLaguerreFilter *wickra_adaptive_laguerre_filter_new(uintptr_t period);

double wickra_adaptive_laguerre_filter_update(struct AdaptiveLaguerreFilter *handle, double value);

void wickra_adaptive_laguerre_filter_batch(struct AdaptiveLaguerreFilter *handle,
                                           const double *input,
                                           double *out,
                                           uintptr_t n);

uintptr_t wickra_adaptive_laguerre_filter_warmup_period(struct AdaptiveLaguerreFilter *handle);

bool wickra_adaptive_laguerre_filter_is_ready(struct AdaptiveLaguerreFilter *handle);

const char *wickra_adaptive_laguerre_filter_name(struct AdaptiveLaguerreFilter *handle);

void wickra_adaptive_laguerre_filter_reset(struct AdaptiveLaguerreFilter *handle);

void wickra_adaptive_laguerre_filter_free(struct AdaptiveLaguerreFilter *handle);

struct AdaptiveRsi *wickra_adaptive_rsi_new(uintptr_t period);

double wickra_adaptive_rsi_update(struct AdaptiveRsi *handle, double value);

void wickra_adaptive_rsi_batch(struct AdaptiveRsi *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_adaptive_rsi_warmup_period(struct AdaptiveRsi *handle);

bool wickra_adaptive_rsi_is_ready(struct AdaptiveRsi *handle);

const char *wickra_adaptive_rsi_name(struct AdaptiveRsi *handle);

void wickra_adaptive_rsi_reset(struct AdaptiveRsi *handle);

void wickra_adaptive_rsi_free(struct AdaptiveRsi *handle);

struct Alma *wickra_alma_new(uintptr_t period, double offset, double sigma);

double wickra_alma_update(struct Alma *handle, double value);

void wickra_alma_batch(struct Alma *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_alma_warmup_period(struct Alma *handle);

bool wickra_alma_is_ready(struct Alma *handle);

const char *wickra_alma_name(struct Alma *handle);

void wickra_alma_reset(struct Alma *handle);

void wickra_alma_free(struct Alma *handle);

struct AnchoredRsi *wickra_anchored_rsi_new(void);

double wickra_anchored_rsi_update(struct AnchoredRsi *handle, double value);

void wickra_anchored_rsi_batch(struct AnchoredRsi *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_anchored_rsi_warmup_period(struct AnchoredRsi *handle);

bool wickra_anchored_rsi_is_ready(struct AnchoredRsi *handle);

const char *wickra_anchored_rsi_name(struct AnchoredRsi *handle);

void wickra_anchored_rsi_reset(struct AnchoredRsi *handle);

void wickra_anchored_rsi_free(struct AnchoredRsi *handle);

struct Apo *wickra_apo_new(uintptr_t fast, uintptr_t slow);

double wickra_apo_update(struct Apo *handle, double value);

void wickra_apo_batch(struct Apo *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_apo_warmup_period(struct Apo *handle);

bool wickra_apo_is_ready(struct Apo *handle);

const char *wickra_apo_name(struct Apo *handle);

void wickra_apo_reset(struct Apo *handle);

void wickra_apo_free(struct Apo *handle);

struct Autocorrelation *wickra_autocorrelation_new(uintptr_t period, uintptr_t lag);

double wickra_autocorrelation_update(struct Autocorrelation *handle, double value);

void wickra_autocorrelation_batch(struct Autocorrelation *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_autocorrelation_warmup_period(struct Autocorrelation *handle);

bool wickra_autocorrelation_is_ready(struct Autocorrelation *handle);

const char *wickra_autocorrelation_name(struct Autocorrelation *handle);

void wickra_autocorrelation_reset(struct Autocorrelation *handle);

void wickra_autocorrelation_free(struct Autocorrelation *handle);

struct AutocorrelationPeriodogram *wickra_autocorrelation_periodogram_new(uintptr_t min_period,
                                                                          uintptr_t max_period);

double wickra_autocorrelation_periodogram_update(struct AutocorrelationPeriodogram *handle,
                                                 double value);

void wickra_autocorrelation_periodogram_batch(struct AutocorrelationPeriodogram *handle,
                                              const double *input,
                                              double *out,
                                              uintptr_t n);

uintptr_t wickra_autocorrelation_periodogram_warmup_period(struct AutocorrelationPeriodogram *handle);

bool wickra_autocorrelation_periodogram_is_ready(struct AutocorrelationPeriodogram *handle);

const char *wickra_autocorrelation_periodogram_name(struct AutocorrelationPeriodogram *handle);

void wickra_autocorrelation_periodogram_reset(struct AutocorrelationPeriodogram *handle);

void wickra_autocorrelation_periodogram_free(struct AutocorrelationPeriodogram *handle);

struct AverageDrawdown *wickra_average_drawdown_new(uintptr_t period);

double wickra_average_drawdown_update(struct AverageDrawdown *handle, double value);

void wickra_average_drawdown_batch(struct AverageDrawdown *handle,
                                   const double *input,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_average_drawdown_warmup_period(struct AverageDrawdown *handle);

bool wickra_average_drawdown_is_ready(struct AverageDrawdown *handle);

const char *wickra_average_drawdown_name(struct AverageDrawdown *handle);

void wickra_average_drawdown_reset(struct AverageDrawdown *handle);

void wickra_average_drawdown_free(struct AverageDrawdown *handle);

struct BandpassFilter *wickra_bandpass_filter_new(uintptr_t period, double bandwidth);

double wickra_bandpass_filter_update(struct BandpassFilter *handle, double value);

void wickra_bandpass_filter_batch(struct BandpassFilter *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_bandpass_filter_warmup_period(struct BandpassFilter *handle);

bool wickra_bandpass_filter_is_ready(struct BandpassFilter *handle);

const char *wickra_bandpass_filter_name(struct BandpassFilter *handle);

void wickra_bandpass_filter_reset(struct BandpassFilter *handle);

void wickra_bandpass_filter_free(struct BandpassFilter *handle);

struct BipowerVariation *wickra_bipower_variation_new(uintptr_t period);

double wickra_bipower_variation_update(struct BipowerVariation *handle, double value);

void wickra_bipower_variation_batch(struct BipowerVariation *handle,
                                    const double *input,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_bipower_variation_warmup_period(struct BipowerVariation *handle);

bool wickra_bipower_variation_is_ready(struct BipowerVariation *handle);

const char *wickra_bipower_variation_name(struct BipowerVariation *handle);

void wickra_bipower_variation_reset(struct BipowerVariation *handle);

void wickra_bipower_variation_free(struct BipowerVariation *handle);

struct BollingerBandwidth *wickra_bollinger_bandwidth_new(uintptr_t period, double multiplier);

double wickra_bollinger_bandwidth_update(struct BollingerBandwidth *handle, double value);

void wickra_bollinger_bandwidth_batch(struct BollingerBandwidth *handle,
                                      const double *input,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_bollinger_bandwidth_warmup_period(struct BollingerBandwidth *handle);

bool wickra_bollinger_bandwidth_is_ready(struct BollingerBandwidth *handle);

const char *wickra_bollinger_bandwidth_name(struct BollingerBandwidth *handle);

void wickra_bollinger_bandwidth_reset(struct BollingerBandwidth *handle);

void wickra_bollinger_bandwidth_free(struct BollingerBandwidth *handle);

struct BurkeRatio *wickra_burke_ratio_new(uintptr_t period);

double wickra_burke_ratio_update(struct BurkeRatio *handle, double value);

void wickra_burke_ratio_batch(struct BurkeRatio *handle,
                              const double *input,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_burke_ratio_warmup_period(struct BurkeRatio *handle);

bool wickra_burke_ratio_is_ready(struct BurkeRatio *handle);

const char *wickra_burke_ratio_name(struct BurkeRatio *handle);

void wickra_burke_ratio_reset(struct BurkeRatio *handle);

void wickra_burke_ratio_free(struct BurkeRatio *handle);

struct CalmarRatio *wickra_calmar_ratio_new(uintptr_t period);

double wickra_calmar_ratio_update(struct CalmarRatio *handle, double value);

void wickra_calmar_ratio_batch(struct CalmarRatio *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_calmar_ratio_warmup_period(struct CalmarRatio *handle);

bool wickra_calmar_ratio_is_ready(struct CalmarRatio *handle);

const char *wickra_calmar_ratio_name(struct CalmarRatio *handle);

void wickra_calmar_ratio_reset(struct CalmarRatio *handle);

void wickra_calmar_ratio_free(struct CalmarRatio *handle);

struct CenterOfGravity *wickra_center_of_gravity_new(uintptr_t period);

double wickra_center_of_gravity_update(struct CenterOfGravity *handle, double value);

void wickra_center_of_gravity_batch(struct CenterOfGravity *handle,
                                    const double *input,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_center_of_gravity_warmup_period(struct CenterOfGravity *handle);

bool wickra_center_of_gravity_is_ready(struct CenterOfGravity *handle);

const char *wickra_center_of_gravity_name(struct CenterOfGravity *handle);

void wickra_center_of_gravity_reset(struct CenterOfGravity *handle);

void wickra_center_of_gravity_free(struct CenterOfGravity *handle);

struct Cfo *wickra_cfo_new(uintptr_t period);

double wickra_cfo_update(struct Cfo *handle, double value);

void wickra_cfo_batch(struct Cfo *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_cfo_warmup_period(struct Cfo *handle);

bool wickra_cfo_is_ready(struct Cfo *handle);

const char *wickra_cfo_name(struct Cfo *handle);

void wickra_cfo_reset(struct Cfo *handle);

void wickra_cfo_free(struct Cfo *handle);

struct Cmo *wickra_cmo_new(uintptr_t period);

double wickra_cmo_update(struct Cmo *handle, double value);

void wickra_cmo_batch(struct Cmo *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_cmo_warmup_period(struct Cmo *handle);

bool wickra_cmo_is_ready(struct Cmo *handle);

const char *wickra_cmo_name(struct Cmo *handle);

void wickra_cmo_reset(struct Cmo *handle);

void wickra_cmo_free(struct Cmo *handle);

struct CoefficientOfVariation *wickra_coefficient_of_variation_new(uintptr_t period);

double wickra_coefficient_of_variation_update(struct CoefficientOfVariation *handle, double value);

void wickra_coefficient_of_variation_batch(struct CoefficientOfVariation *handle,
                                           const double *input,
                                           double *out,
                                           uintptr_t n);

uintptr_t wickra_coefficient_of_variation_warmup_period(struct CoefficientOfVariation *handle);

bool wickra_coefficient_of_variation_is_ready(struct CoefficientOfVariation *handle);

const char *wickra_coefficient_of_variation_name(struct CoefficientOfVariation *handle);

void wickra_coefficient_of_variation_reset(struct CoefficientOfVariation *handle);

void wickra_coefficient_of_variation_free(struct CoefficientOfVariation *handle);

struct CommonSenseRatio *wickra_common_sense_ratio_new(uintptr_t period);

double wickra_common_sense_ratio_update(struct CommonSenseRatio *handle, double value);

void wickra_common_sense_ratio_batch(struct CommonSenseRatio *handle,
                                     const double *input,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_common_sense_ratio_warmup_period(struct CommonSenseRatio *handle);

bool wickra_common_sense_ratio_is_ready(struct CommonSenseRatio *handle);

const char *wickra_common_sense_ratio_name(struct CommonSenseRatio *handle);

void wickra_common_sense_ratio_reset(struct CommonSenseRatio *handle);

void wickra_common_sense_ratio_free(struct CommonSenseRatio *handle);

struct ConditionalValueAtRisk *wickra_conditional_value_at_risk_new(uintptr_t period,
                                                                    double confidence);

double wickra_conditional_value_at_risk_update(struct ConditionalValueAtRisk *handle, double value);

void wickra_conditional_value_at_risk_batch(struct ConditionalValueAtRisk *handle,
                                            const double *input,
                                            double *out,
                                            uintptr_t n);

uintptr_t wickra_conditional_value_at_risk_warmup_period(struct ConditionalValueAtRisk *handle);

bool wickra_conditional_value_at_risk_is_ready(struct ConditionalValueAtRisk *handle);

const char *wickra_conditional_value_at_risk_name(struct ConditionalValueAtRisk *handle);

void wickra_conditional_value_at_risk_reset(struct ConditionalValueAtRisk *handle);

void wickra_conditional_value_at_risk_free(struct ConditionalValueAtRisk *handle);

struct ConnorsRsi *wickra_connors_rsi_new(uintptr_t period_rsi,
                                          uintptr_t period_streak,
                                          uintptr_t period_rank);

double wickra_connors_rsi_update(struct ConnorsRsi *handle, double value);

void wickra_connors_rsi_batch(struct ConnorsRsi *handle,
                              const double *input,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_connors_rsi_warmup_period(struct ConnorsRsi *handle);

bool wickra_connors_rsi_is_ready(struct ConnorsRsi *handle);

const char *wickra_connors_rsi_name(struct ConnorsRsi *handle);

void wickra_connors_rsi_reset(struct ConnorsRsi *handle);

void wickra_connors_rsi_free(struct ConnorsRsi *handle);

struct Coppock *wickra_coppock_new(uintptr_t roc_long_period,
                                   uintptr_t roc_short_period,
                                   uintptr_t wma_period);

double wickra_coppock_update(struct Coppock *handle, double value);

void wickra_coppock_batch(struct Coppock *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_coppock_warmup_period(struct Coppock *handle);

bool wickra_coppock_is_ready(struct Coppock *handle);

const char *wickra_coppock_name(struct Coppock *handle);

void wickra_coppock_reset(struct Coppock *handle);

void wickra_coppock_free(struct Coppock *handle);

struct CorrelationTrendIndicator *wickra_correlation_trend_indicator_new(uintptr_t period);

double wickra_correlation_trend_indicator_update(struct CorrelationTrendIndicator *handle,
                                                 double value);

void wickra_correlation_trend_indicator_batch(struct CorrelationTrendIndicator *handle,
                                              const double *input,
                                              double *out,
                                              uintptr_t n);

uintptr_t wickra_correlation_trend_indicator_warmup_period(struct CorrelationTrendIndicator *handle);

bool wickra_correlation_trend_indicator_is_ready(struct CorrelationTrendIndicator *handle);

const char *wickra_correlation_trend_indicator_name(struct CorrelationTrendIndicator *handle);

void wickra_correlation_trend_indicator_reset(struct CorrelationTrendIndicator *handle);

void wickra_correlation_trend_indicator_free(struct CorrelationTrendIndicator *handle);

struct CyberneticCycle *wickra_cybernetic_cycle_new(uintptr_t period);

double wickra_cybernetic_cycle_update(struct CyberneticCycle *handle, double value);

void wickra_cybernetic_cycle_batch(struct CyberneticCycle *handle,
                                   const double *input,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_cybernetic_cycle_warmup_period(struct CyberneticCycle *handle);

bool wickra_cybernetic_cycle_is_ready(struct CyberneticCycle *handle);

const char *wickra_cybernetic_cycle_name(struct CyberneticCycle *handle);

void wickra_cybernetic_cycle_reset(struct CyberneticCycle *handle);

void wickra_cybernetic_cycle_free(struct CyberneticCycle *handle);

struct Decycler *wickra_decycler_new(uintptr_t period);

double wickra_decycler_update(struct Decycler *handle, double value);

void wickra_decycler_batch(struct Decycler *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_decycler_warmup_period(struct Decycler *handle);

bool wickra_decycler_is_ready(struct Decycler *handle);

const char *wickra_decycler_name(struct Decycler *handle);

void wickra_decycler_reset(struct Decycler *handle);

void wickra_decycler_free(struct Decycler *handle);

struct DecyclerOscillator *wickra_decycler_oscillator_new(uintptr_t fast, uintptr_t slow);

double wickra_decycler_oscillator_update(struct DecyclerOscillator *handle, double value);

void wickra_decycler_oscillator_batch(struct DecyclerOscillator *handle,
                                      const double *input,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_decycler_oscillator_warmup_period(struct DecyclerOscillator *handle);

bool wickra_decycler_oscillator_is_ready(struct DecyclerOscillator *handle);

const char *wickra_decycler_oscillator_name(struct DecyclerOscillator *handle);

void wickra_decycler_oscillator_reset(struct DecyclerOscillator *handle);

void wickra_decycler_oscillator_free(struct DecyclerOscillator *handle);

struct Dema *wickra_dema_new(uintptr_t period);

double wickra_dema_update(struct Dema *handle, double value);

void wickra_dema_batch(struct Dema *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_dema_warmup_period(struct Dema *handle);

bool wickra_dema_is_ready(struct Dema *handle);

const char *wickra_dema_name(struct Dema *handle);

void wickra_dema_reset(struct Dema *handle);

void wickra_dema_free(struct Dema *handle);

struct DerivativeOscillator *wickra_derivative_oscillator_new(uintptr_t rsi_period,
                                                              uintptr_t smooth1,
                                                              uintptr_t smooth2,
                                                              uintptr_t signal_period);

double wickra_derivative_oscillator_update(struct DerivativeOscillator *handle, double value);

void wickra_derivative_oscillator_batch(struct DerivativeOscillator *handle,
                                        const double *input,
                                        double *out,
                                        uintptr_t n);

uintptr_t wickra_derivative_oscillator_warmup_period(struct DerivativeOscillator *handle);

bool wickra_derivative_oscillator_is_ready(struct DerivativeOscillator *handle);

const char *wickra_derivative_oscillator_name(struct DerivativeOscillator *handle);

void wickra_derivative_oscillator_reset(struct DerivativeOscillator *handle);

void wickra_derivative_oscillator_free(struct DerivativeOscillator *handle);

struct DetrendedStdDev *wickra_detrended_std_dev_new(uintptr_t period);

double wickra_detrended_std_dev_update(struct DetrendedStdDev *handle, double value);

void wickra_detrended_std_dev_batch(struct DetrendedStdDev *handle,
                                    const double *input,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_detrended_std_dev_warmup_period(struct DetrendedStdDev *handle);

bool wickra_detrended_std_dev_is_ready(struct DetrendedStdDev *handle);

const char *wickra_detrended_std_dev_name(struct DetrendedStdDev *handle);

void wickra_detrended_std_dev_reset(struct DetrendedStdDev *handle);

void wickra_detrended_std_dev_free(struct DetrendedStdDev *handle);

struct DisparityIndex *wickra_disparity_index_new(uintptr_t period);

double wickra_disparity_index_update(struct DisparityIndex *handle, double value);

void wickra_disparity_index_batch(struct DisparityIndex *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_disparity_index_warmup_period(struct DisparityIndex *handle);

bool wickra_disparity_index_is_ready(struct DisparityIndex *handle);

const char *wickra_disparity_index_name(struct DisparityIndex *handle);

void wickra_disparity_index_reset(struct DisparityIndex *handle);

void wickra_disparity_index_free(struct DisparityIndex *handle);

struct Dpo *wickra_dpo_new(uintptr_t period);

double wickra_dpo_update(struct Dpo *handle, double value);

void wickra_dpo_batch(struct Dpo *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_dpo_warmup_period(struct Dpo *handle);

bool wickra_dpo_is_ready(struct Dpo *handle);

const char *wickra_dpo_name(struct Dpo *handle);

void wickra_dpo_reset(struct Dpo *handle);

void wickra_dpo_free(struct Dpo *handle);

struct DrawdownDuration *wickra_drawdown_duration_new(void);

double wickra_drawdown_duration_update(struct DrawdownDuration *handle, double value);

void wickra_drawdown_duration_batch(struct DrawdownDuration *handle,
                                    const double *input,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_drawdown_duration_warmup_period(struct DrawdownDuration *handle);

bool wickra_drawdown_duration_is_ready(struct DrawdownDuration *handle);

const char *wickra_drawdown_duration_name(struct DrawdownDuration *handle);

void wickra_drawdown_duration_reset(struct DrawdownDuration *handle);

void wickra_drawdown_duration_free(struct DrawdownDuration *handle);

struct DynamicMomentumIndex *wickra_dynamic_momentum_index_new(uintptr_t period);

double wickra_dynamic_momentum_index_update(struct DynamicMomentumIndex *handle, double value);

void wickra_dynamic_momentum_index_batch(struct DynamicMomentumIndex *handle,
                                         const double *input,
                                         double *out,
                                         uintptr_t n);

uintptr_t wickra_dynamic_momentum_index_warmup_period(struct DynamicMomentumIndex *handle);

bool wickra_dynamic_momentum_index_is_ready(struct DynamicMomentumIndex *handle);

const char *wickra_dynamic_momentum_index_name(struct DynamicMomentumIndex *handle);

void wickra_dynamic_momentum_index_reset(struct DynamicMomentumIndex *handle);

void wickra_dynamic_momentum_index_free(struct DynamicMomentumIndex *handle);

struct EhlersStochastic *wickra_ehlers_stochastic_new(uintptr_t period);

double wickra_ehlers_stochastic_update(struct EhlersStochastic *handle, double value);

void wickra_ehlers_stochastic_batch(struct EhlersStochastic *handle,
                                    const double *input,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_ehlers_stochastic_warmup_period(struct EhlersStochastic *handle);

bool wickra_ehlers_stochastic_is_ready(struct EhlersStochastic *handle);

const char *wickra_ehlers_stochastic_name(struct EhlersStochastic *handle);

void wickra_ehlers_stochastic_reset(struct EhlersStochastic *handle);

void wickra_ehlers_stochastic_free(struct EhlersStochastic *handle);

struct Ehma *wickra_ehma_new(uintptr_t period);

double wickra_ehma_update(struct Ehma *handle, double value);

void wickra_ehma_batch(struct Ehma *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_ehma_warmup_period(struct Ehma *handle);

bool wickra_ehma_is_ready(struct Ehma *handle);

const char *wickra_ehma_name(struct Ehma *handle);

void wickra_ehma_reset(struct Ehma *handle);

void wickra_ehma_free(struct Ehma *handle);

struct ElderImpulse *wickra_elder_impulse_new(uintptr_t ema_period,
                                              uintptr_t macd_fast,
                                              uintptr_t macd_slow,
                                              uintptr_t macd_signal);

double wickra_elder_impulse_update(struct ElderImpulse *handle, double value);

void wickra_elder_impulse_batch(struct ElderImpulse *handle,
                                const double *input,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_elder_impulse_warmup_period(struct ElderImpulse *handle);

bool wickra_elder_impulse_is_ready(struct ElderImpulse *handle);

const char *wickra_elder_impulse_name(struct ElderImpulse *handle);

void wickra_elder_impulse_reset(struct ElderImpulse *handle);

void wickra_elder_impulse_free(struct ElderImpulse *handle);

struct Ema *wickra_ema_new(uintptr_t period);

double wickra_ema_update(struct Ema *handle, double value);

void wickra_ema_batch(struct Ema *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_ema_warmup_period(struct Ema *handle);

bool wickra_ema_is_ready(struct Ema *handle);

const char *wickra_ema_name(struct Ema *handle);

void wickra_ema_reset(struct Ema *handle);

void wickra_ema_free(struct Ema *handle);

struct EmpiricalModeDecomposition *wickra_empirical_mode_decomposition_new(uintptr_t period,
                                                                           double fraction);

double wickra_empirical_mode_decomposition_update(struct EmpiricalModeDecomposition *handle,
                                                  double value);

void wickra_empirical_mode_decomposition_batch(struct EmpiricalModeDecomposition *handle,
                                               const double *input,
                                               double *out,
                                               uintptr_t n);

uintptr_t wickra_empirical_mode_decomposition_warmup_period(struct EmpiricalModeDecomposition *handle);

bool wickra_empirical_mode_decomposition_is_ready(struct EmpiricalModeDecomposition *handle);

const char *wickra_empirical_mode_decomposition_name(struct EmpiricalModeDecomposition *handle);

void wickra_empirical_mode_decomposition_reset(struct EmpiricalModeDecomposition *handle);

void wickra_empirical_mode_decomposition_free(struct EmpiricalModeDecomposition *handle);

struct EvenBetterSinewave *wickra_even_better_sinewave_new(uintptr_t hp_period,
                                                           uintptr_t ssf_length);

double wickra_even_better_sinewave_update(struct EvenBetterSinewave *handle, double value);

void wickra_even_better_sinewave_batch(struct EvenBetterSinewave *handle,
                                       const double *input,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_even_better_sinewave_warmup_period(struct EvenBetterSinewave *handle);

bool wickra_even_better_sinewave_is_ready(struct EvenBetterSinewave *handle);

const char *wickra_even_better_sinewave_name(struct EvenBetterSinewave *handle);

void wickra_even_better_sinewave_reset(struct EvenBetterSinewave *handle);

void wickra_even_better_sinewave_free(struct EvenBetterSinewave *handle);

struct EwmaVolatility *wickra_ewma_volatility_new(double lambda);

double wickra_ewma_volatility_update(struct EwmaVolatility *handle, double value);

void wickra_ewma_volatility_batch(struct EwmaVolatility *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_ewma_volatility_warmup_period(struct EwmaVolatility *handle);

bool wickra_ewma_volatility_is_ready(struct EwmaVolatility *handle);

const char *wickra_ewma_volatility_name(struct EwmaVolatility *handle);

void wickra_ewma_volatility_reset(struct EwmaVolatility *handle);

void wickra_ewma_volatility_free(struct EwmaVolatility *handle);

struct Expectancy *wickra_expectancy_new(uintptr_t period);

double wickra_expectancy_update(struct Expectancy *handle, double value);

void wickra_expectancy_batch(struct Expectancy *handle,
                             const double *input,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_expectancy_warmup_period(struct Expectancy *handle);

bool wickra_expectancy_is_ready(struct Expectancy *handle);

const char *wickra_expectancy_name(struct Expectancy *handle);

void wickra_expectancy_reset(struct Expectancy *handle);

void wickra_expectancy_free(struct Expectancy *handle);

struct Fama *wickra_fama_new(double fast_limit, double slow_limit);

double wickra_fama_update(struct Fama *handle, double value);

void wickra_fama_batch(struct Fama *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_fama_warmup_period(struct Fama *handle);

bool wickra_fama_is_ready(struct Fama *handle);

const char *wickra_fama_name(struct Fama *handle);

void wickra_fama_reset(struct Fama *handle);

void wickra_fama_free(struct Fama *handle);

struct FisherRsi *wickra_fisher_rsi_new(uintptr_t period);

double wickra_fisher_rsi_update(struct FisherRsi *handle, double value);

void wickra_fisher_rsi_batch(struct FisherRsi *handle,
                             const double *input,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_fisher_rsi_warmup_period(struct FisherRsi *handle);

bool wickra_fisher_rsi_is_ready(struct FisherRsi *handle);

const char *wickra_fisher_rsi_name(struct FisherRsi *handle);

void wickra_fisher_rsi_reset(struct FisherRsi *handle);

void wickra_fisher_rsi_free(struct FisherRsi *handle);

struct FisherTransform *wickra_fisher_transform_new(uintptr_t period);

double wickra_fisher_transform_update(struct FisherTransform *handle, double value);

void wickra_fisher_transform_batch(struct FisherTransform *handle,
                                   const double *input,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_fisher_transform_warmup_period(struct FisherTransform *handle);

bool wickra_fisher_transform_is_ready(struct FisherTransform *handle);

const char *wickra_fisher_transform_name(struct FisherTransform *handle);

void wickra_fisher_transform_reset(struct FisherTransform *handle);

void wickra_fisher_transform_free(struct FisherTransform *handle);

struct Frama *wickra_frama_new(uintptr_t period);

double wickra_frama_update(struct Frama *handle, double value);

void wickra_frama_batch(struct Frama *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_frama_warmup_period(struct Frama *handle);

bool wickra_frama_is_ready(struct Frama *handle);

const char *wickra_frama_name(struct Frama *handle);

void wickra_frama_reset(struct Frama *handle);

void wickra_frama_free(struct Frama *handle);

struct GainLossRatio *wickra_gain_loss_ratio_new(uintptr_t period);

double wickra_gain_loss_ratio_update(struct GainLossRatio *handle, double value);

void wickra_gain_loss_ratio_batch(struct GainLossRatio *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_gain_loss_ratio_warmup_period(struct GainLossRatio *handle);

bool wickra_gain_loss_ratio_is_ready(struct GainLossRatio *handle);

const char *wickra_gain_loss_ratio_name(struct GainLossRatio *handle);

void wickra_gain_loss_ratio_reset(struct GainLossRatio *handle);

void wickra_gain_loss_ratio_free(struct GainLossRatio *handle);

struct GainToPainRatio *wickra_gain_to_pain_ratio_new(uintptr_t period);

double wickra_gain_to_pain_ratio_update(struct GainToPainRatio *handle, double value);

void wickra_gain_to_pain_ratio_batch(struct GainToPainRatio *handle,
                                     const double *input,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_gain_to_pain_ratio_warmup_period(struct GainToPainRatio *handle);

bool wickra_gain_to_pain_ratio_is_ready(struct GainToPainRatio *handle);

const char *wickra_gain_to_pain_ratio_name(struct GainToPainRatio *handle);

void wickra_gain_to_pain_ratio_reset(struct GainToPainRatio *handle);

void wickra_gain_to_pain_ratio_free(struct GainToPainRatio *handle);

struct Garch11 *wickra_garch11_new(double omega, double alpha, double beta);

double wickra_garch11_update(struct Garch11 *handle, double value);

void wickra_garch11_batch(struct Garch11 *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_garch11_warmup_period(struct Garch11 *handle);

bool wickra_garch11_is_ready(struct Garch11 *handle);

const char *wickra_garch11_name(struct Garch11 *handle);

void wickra_garch11_reset(struct Garch11 *handle);

void wickra_garch11_free(struct Garch11 *handle);

struct GeneralizedDema *wickra_generalized_dema_new(uintptr_t period, double v);

double wickra_generalized_dema_update(struct GeneralizedDema *handle, double value);

void wickra_generalized_dema_batch(struct GeneralizedDema *handle,
                                   const double *input,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_generalized_dema_warmup_period(struct GeneralizedDema *handle);

bool wickra_generalized_dema_is_ready(struct GeneralizedDema *handle);

const char *wickra_generalized_dema_name(struct GeneralizedDema *handle);

void wickra_generalized_dema_reset(struct GeneralizedDema *handle);

void wickra_generalized_dema_free(struct GeneralizedDema *handle);

struct GeometricMa *wickra_geometric_ma_new(uintptr_t period);

double wickra_geometric_ma_update(struct GeometricMa *handle, double value);

void wickra_geometric_ma_batch(struct GeometricMa *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_geometric_ma_warmup_period(struct GeometricMa *handle);

bool wickra_geometric_ma_is_ready(struct GeometricMa *handle);

const char *wickra_geometric_ma_name(struct GeometricMa *handle);

void wickra_geometric_ma_reset(struct GeometricMa *handle);

void wickra_geometric_ma_free(struct GeometricMa *handle);

struct HighpassFilter *wickra_highpass_filter_new(uintptr_t period);

double wickra_highpass_filter_update(struct HighpassFilter *handle, double value);

void wickra_highpass_filter_batch(struct HighpassFilter *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_highpass_filter_warmup_period(struct HighpassFilter *handle);

bool wickra_highpass_filter_is_ready(struct HighpassFilter *handle);

const char *wickra_highpass_filter_name(struct HighpassFilter *handle);

void wickra_highpass_filter_reset(struct HighpassFilter *handle);

void wickra_highpass_filter_free(struct HighpassFilter *handle);

struct HilbertDominantCycle *wickra_hilbert_dominant_cycle_new(void);

double wickra_hilbert_dominant_cycle_update(struct HilbertDominantCycle *handle, double value);

void wickra_hilbert_dominant_cycle_batch(struct HilbertDominantCycle *handle,
                                         const double *input,
                                         double *out,
                                         uintptr_t n);

uintptr_t wickra_hilbert_dominant_cycle_warmup_period(struct HilbertDominantCycle *handle);

bool wickra_hilbert_dominant_cycle_is_ready(struct HilbertDominantCycle *handle);

const char *wickra_hilbert_dominant_cycle_name(struct HilbertDominantCycle *handle);

void wickra_hilbert_dominant_cycle_reset(struct HilbertDominantCycle *handle);

void wickra_hilbert_dominant_cycle_free(struct HilbertDominantCycle *handle);

struct HistoricalVolatility *wickra_historical_volatility_new(uintptr_t period,
                                                              uintptr_t trading_periods);

double wickra_historical_volatility_update(struct HistoricalVolatility *handle, double value);

void wickra_historical_volatility_batch(struct HistoricalVolatility *handle,
                                        const double *input,
                                        double *out,
                                        uintptr_t n);

uintptr_t wickra_historical_volatility_warmup_period(struct HistoricalVolatility *handle);

bool wickra_historical_volatility_is_ready(struct HistoricalVolatility *handle);

const char *wickra_historical_volatility_name(struct HistoricalVolatility *handle);

void wickra_historical_volatility_reset(struct HistoricalVolatility *handle);

void wickra_historical_volatility_free(struct HistoricalVolatility *handle);

struct Hma *wickra_hma_new(uintptr_t period);

double wickra_hma_update(struct Hma *handle, double value);

void wickra_hma_batch(struct Hma *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_hma_warmup_period(struct Hma *handle);

bool wickra_hma_is_ready(struct Hma *handle);

const char *wickra_hma_name(struct Hma *handle);

void wickra_hma_reset(struct Hma *handle);

void wickra_hma_free(struct Hma *handle);

struct HoltWinters *wickra_holt_winters_new(double alpha, double beta);

double wickra_holt_winters_update(struct HoltWinters *handle, double value);

void wickra_holt_winters_batch(struct HoltWinters *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_holt_winters_warmup_period(struct HoltWinters *handle);

bool wickra_holt_winters_is_ready(struct HoltWinters *handle);

const char *wickra_holt_winters_name(struct HoltWinters *handle);

void wickra_holt_winters_reset(struct HoltWinters *handle);

void wickra_holt_winters_free(struct HoltWinters *handle);

struct HtDcPhase *wickra_ht_dc_phase_new(void);

double wickra_ht_dc_phase_update(struct HtDcPhase *handle, double value);

void wickra_ht_dc_phase_batch(struct HtDcPhase *handle,
                              const double *input,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_ht_dc_phase_warmup_period(struct HtDcPhase *handle);

bool wickra_ht_dc_phase_is_ready(struct HtDcPhase *handle);

const char *wickra_ht_dc_phase_name(struct HtDcPhase *handle);

void wickra_ht_dc_phase_reset(struct HtDcPhase *handle);

void wickra_ht_dc_phase_free(struct HtDcPhase *handle);

struct HtTrendMode *wickra_ht_trend_mode_new(void);

double wickra_ht_trend_mode_update(struct HtTrendMode *handle, double value);

void wickra_ht_trend_mode_batch(struct HtTrendMode *handle,
                                const double *input,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_ht_trend_mode_warmup_period(struct HtTrendMode *handle);

bool wickra_ht_trend_mode_is_ready(struct HtTrendMode *handle);

const char *wickra_ht_trend_mode_name(struct HtTrendMode *handle);

void wickra_ht_trend_mode_reset(struct HtTrendMode *handle);

void wickra_ht_trend_mode_free(struct HtTrendMode *handle);

struct HurstExponent *wickra_hurst_exponent_new(uintptr_t period, uintptr_t chunks);

double wickra_hurst_exponent_update(struct HurstExponent *handle, double value);

void wickra_hurst_exponent_batch(struct HurstExponent *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_hurst_exponent_warmup_period(struct HurstExponent *handle);

bool wickra_hurst_exponent_is_ready(struct HurstExponent *handle);

const char *wickra_hurst_exponent_name(struct HurstExponent *handle);

void wickra_hurst_exponent_reset(struct HurstExponent *handle);

void wickra_hurst_exponent_free(struct HurstExponent *handle);

struct InstantaneousTrendline *wickra_instantaneous_trendline_new(uintptr_t period);

double wickra_instantaneous_trendline_update(struct InstantaneousTrendline *handle, double value);

void wickra_instantaneous_trendline_batch(struct InstantaneousTrendline *handle,
                                          const double *input,
                                          double *out,
                                          uintptr_t n);

uintptr_t wickra_instantaneous_trendline_warmup_period(struct InstantaneousTrendline *handle);

bool wickra_instantaneous_trendline_is_ready(struct InstantaneousTrendline *handle);

const char *wickra_instantaneous_trendline_name(struct InstantaneousTrendline *handle);

void wickra_instantaneous_trendline_reset(struct InstantaneousTrendline *handle);

void wickra_instantaneous_trendline_free(struct InstantaneousTrendline *handle);

struct InverseFisherTransform *wickra_inverse_fisher_transform_new(double scale);

double wickra_inverse_fisher_transform_update(struct InverseFisherTransform *handle, double value);

void wickra_inverse_fisher_transform_batch(struct InverseFisherTransform *handle,
                                           const double *input,
                                           double *out,
                                           uintptr_t n);

uintptr_t wickra_inverse_fisher_transform_warmup_period(struct InverseFisherTransform *handle);

bool wickra_inverse_fisher_transform_is_ready(struct InverseFisherTransform *handle);

const char *wickra_inverse_fisher_transform_name(struct InverseFisherTransform *handle);

void wickra_inverse_fisher_transform_reset(struct InverseFisherTransform *handle);

void wickra_inverse_fisher_transform_free(struct InverseFisherTransform *handle);

struct JarqueBera *wickra_jarque_bera_new(uintptr_t period);

double wickra_jarque_bera_update(struct JarqueBera *handle, double value);

void wickra_jarque_bera_batch(struct JarqueBera *handle,
                              const double *input,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_jarque_bera_warmup_period(struct JarqueBera *handle);

bool wickra_jarque_bera_is_ready(struct JarqueBera *handle);

const char *wickra_jarque_bera_name(struct JarqueBera *handle);

void wickra_jarque_bera_reset(struct JarqueBera *handle);

void wickra_jarque_bera_free(struct JarqueBera *handle);

struct Jma *wickra_jma_new(uintptr_t period, double phase, uint32_t power);

double wickra_jma_update(struct Jma *handle, double value);

void wickra_jma_batch(struct Jma *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_jma_warmup_period(struct Jma *handle);

bool wickra_jma_is_ready(struct Jma *handle);

const char *wickra_jma_name(struct Jma *handle);

void wickra_jma_reset(struct Jma *handle);

void wickra_jma_free(struct Jma *handle);

struct JumpIndicator *wickra_jump_indicator_new(uintptr_t period, double threshold);

double wickra_jump_indicator_update(struct JumpIndicator *handle, double value);

void wickra_jump_indicator_batch(struct JumpIndicator *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_jump_indicator_warmup_period(struct JumpIndicator *handle);

bool wickra_jump_indicator_is_ready(struct JumpIndicator *handle);

const char *wickra_jump_indicator_name(struct JumpIndicator *handle);

void wickra_jump_indicator_reset(struct JumpIndicator *handle);

void wickra_jump_indicator_free(struct JumpIndicator *handle);

struct KRatio *wickra_k_ratio_new(uintptr_t period);

double wickra_k_ratio_update(struct KRatio *handle, double value);

void wickra_k_ratio_batch(struct KRatio *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_k_ratio_warmup_period(struct KRatio *handle);

bool wickra_k_ratio_is_ready(struct KRatio *handle);

const char *wickra_k_ratio_name(struct KRatio *handle);

void wickra_k_ratio_reset(struct KRatio *handle);

void wickra_k_ratio_free(struct KRatio *handle);

struct Kama *wickra_kama_new(uintptr_t er_period, uintptr_t fast, uintptr_t slow);

double wickra_kama_update(struct Kama *handle, double value);

void wickra_kama_batch(struct Kama *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_kama_warmup_period(struct Kama *handle);

bool wickra_kama_is_ready(struct Kama *handle);

const char *wickra_kama_name(struct Kama *handle);

void wickra_kama_reset(struct Kama *handle);

void wickra_kama_free(struct Kama *handle);

struct KellyCriterion *wickra_kelly_criterion_new(uintptr_t period);

double wickra_kelly_criterion_update(struct KellyCriterion *handle, double value);

void wickra_kelly_criterion_batch(struct KellyCriterion *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_kelly_criterion_warmup_period(struct KellyCriterion *handle);

bool wickra_kelly_criterion_is_ready(struct KellyCriterion *handle);

const char *wickra_kelly_criterion_name(struct KellyCriterion *handle);

void wickra_kelly_criterion_reset(struct KellyCriterion *handle);

void wickra_kelly_criterion_free(struct KellyCriterion *handle);

struct Kurtosis *wickra_kurtosis_new(uintptr_t period);

double wickra_kurtosis_update(struct Kurtosis *handle, double value);

void wickra_kurtosis_batch(struct Kurtosis *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_kurtosis_warmup_period(struct Kurtosis *handle);

bool wickra_kurtosis_is_ready(struct Kurtosis *handle);

const char *wickra_kurtosis_name(struct Kurtosis *handle);

void wickra_kurtosis_reset(struct Kurtosis *handle);

void wickra_kurtosis_free(struct Kurtosis *handle);

struct LaguerreRsi *wickra_laguerre_rsi_new(double gamma);

double wickra_laguerre_rsi_update(struct LaguerreRsi *handle, double value);

void wickra_laguerre_rsi_batch(struct LaguerreRsi *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_laguerre_rsi_warmup_period(struct LaguerreRsi *handle);

bool wickra_laguerre_rsi_is_ready(struct LaguerreRsi *handle);

const char *wickra_laguerre_rsi_name(struct LaguerreRsi *handle);

void wickra_laguerre_rsi_reset(struct LaguerreRsi *handle);

void wickra_laguerre_rsi_free(struct LaguerreRsi *handle);

struct LinearRegression *wickra_linear_regression_new(uintptr_t period);

double wickra_linear_regression_update(struct LinearRegression *handle, double value);

void wickra_linear_regression_batch(struct LinearRegression *handle,
                                    const double *input,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_linear_regression_warmup_period(struct LinearRegression *handle);

bool wickra_linear_regression_is_ready(struct LinearRegression *handle);

const char *wickra_linear_regression_name(struct LinearRegression *handle);

void wickra_linear_regression_reset(struct LinearRegression *handle);

void wickra_linear_regression_free(struct LinearRegression *handle);

struct LinRegAngle *wickra_lin_reg_angle_new(uintptr_t period);

double wickra_lin_reg_angle_update(struct LinRegAngle *handle, double value);

void wickra_lin_reg_angle_batch(struct LinRegAngle *handle,
                                const double *input,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_lin_reg_angle_warmup_period(struct LinRegAngle *handle);

bool wickra_lin_reg_angle_is_ready(struct LinRegAngle *handle);

const char *wickra_lin_reg_angle_name(struct LinRegAngle *handle);

void wickra_lin_reg_angle_reset(struct LinRegAngle *handle);

void wickra_lin_reg_angle_free(struct LinRegAngle *handle);

struct LinRegIntercept *wickra_lin_reg_intercept_new(uintptr_t period);

double wickra_lin_reg_intercept_update(struct LinRegIntercept *handle, double value);

void wickra_lin_reg_intercept_batch(struct LinRegIntercept *handle,
                                    const double *input,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_lin_reg_intercept_warmup_period(struct LinRegIntercept *handle);

bool wickra_lin_reg_intercept_is_ready(struct LinRegIntercept *handle);

const char *wickra_lin_reg_intercept_name(struct LinRegIntercept *handle);

void wickra_lin_reg_intercept_reset(struct LinRegIntercept *handle);

void wickra_lin_reg_intercept_free(struct LinRegIntercept *handle);

struct LinRegSlope *wickra_lin_reg_slope_new(uintptr_t period);

double wickra_lin_reg_slope_update(struct LinRegSlope *handle, double value);

void wickra_lin_reg_slope_batch(struct LinRegSlope *handle,
                                const double *input,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_lin_reg_slope_warmup_period(struct LinRegSlope *handle);

bool wickra_lin_reg_slope_is_ready(struct LinRegSlope *handle);

const char *wickra_lin_reg_slope_name(struct LinRegSlope *handle);

void wickra_lin_reg_slope_reset(struct LinRegSlope *handle);

void wickra_lin_reg_slope_free(struct LinRegSlope *handle);

struct LogReturn *wickra_log_return_new(uintptr_t period);

double wickra_log_return_update(struct LogReturn *handle, double value);

void wickra_log_return_batch(struct LogReturn *handle,
                             const double *input,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_log_return_warmup_period(struct LogReturn *handle);

bool wickra_log_return_is_ready(struct LogReturn *handle);

const char *wickra_log_return_name(struct LogReturn *handle);

void wickra_log_return_reset(struct LogReturn *handle);

void wickra_log_return_free(struct LogReturn *handle);

struct M2Measure *wickra_m2_measure_new(uintptr_t period,
                                        double risk_free,
                                        double benchmark_stddev);

double wickra_m2_measure_update(struct M2Measure *handle, double value);

void wickra_m2_measure_batch(struct M2Measure *handle,
                             const double *input,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_m2_measure_warmup_period(struct M2Measure *handle);

bool wickra_m2_measure_is_ready(struct M2Measure *handle);

const char *wickra_m2_measure_name(struct M2Measure *handle);

void wickra_m2_measure_reset(struct M2Measure *handle);

void wickra_m2_measure_free(struct M2Measure *handle);

struct MacdHistogram *wickra_macd_histogram_new(uintptr_t fast, uintptr_t slow, uintptr_t signal);

double wickra_macd_histogram_update(struct MacdHistogram *handle, double value);

void wickra_macd_histogram_batch(struct MacdHistogram *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_macd_histogram_warmup_period(struct MacdHistogram *handle);

bool wickra_macd_histogram_is_ready(struct MacdHistogram *handle);

const char *wickra_macd_histogram_name(struct MacdHistogram *handle);

void wickra_macd_histogram_reset(struct MacdHistogram *handle);

void wickra_macd_histogram_free(struct MacdHistogram *handle);

struct MartinRatio *wickra_martin_ratio_new(uintptr_t period);

double wickra_martin_ratio_update(struct MartinRatio *handle, double value);

void wickra_martin_ratio_batch(struct MartinRatio *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_martin_ratio_warmup_period(struct MartinRatio *handle);

bool wickra_martin_ratio_is_ready(struct MartinRatio *handle);

const char *wickra_martin_ratio_name(struct MartinRatio *handle);

void wickra_martin_ratio_reset(struct MartinRatio *handle);

void wickra_martin_ratio_free(struct MartinRatio *handle);

struct MaxDrawdown *wickra_max_drawdown_new(uintptr_t period);

double wickra_max_drawdown_update(struct MaxDrawdown *handle, double value);

void wickra_max_drawdown_batch(struct MaxDrawdown *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_max_drawdown_warmup_period(struct MaxDrawdown *handle);

bool wickra_max_drawdown_is_ready(struct MaxDrawdown *handle);

const char *wickra_max_drawdown_name(struct MaxDrawdown *handle);

void wickra_max_drawdown_reset(struct MaxDrawdown *handle);

void wickra_max_drawdown_free(struct MaxDrawdown *handle);

struct McGinleyDynamic *wickra_mc_ginley_dynamic_new(uintptr_t period);

double wickra_mc_ginley_dynamic_update(struct McGinleyDynamic *handle, double value);

void wickra_mc_ginley_dynamic_batch(struct McGinleyDynamic *handle,
                                    const double *input,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_mc_ginley_dynamic_warmup_period(struct McGinleyDynamic *handle);

bool wickra_mc_ginley_dynamic_is_ready(struct McGinleyDynamic *handle);

const char *wickra_mc_ginley_dynamic_name(struct McGinleyDynamic *handle);

void wickra_mc_ginley_dynamic_reset(struct McGinleyDynamic *handle);

void wickra_mc_ginley_dynamic_free(struct McGinleyDynamic *handle);

struct MedianAbsoluteDeviation *wickra_median_absolute_deviation_new(uintptr_t period);

double wickra_median_absolute_deviation_update(struct MedianAbsoluteDeviation *handle,
                                               double value);

void wickra_median_absolute_deviation_batch(struct MedianAbsoluteDeviation *handle,
                                            const double *input,
                                            double *out,
                                            uintptr_t n);

uintptr_t wickra_median_absolute_deviation_warmup_period(struct MedianAbsoluteDeviation *handle);

bool wickra_median_absolute_deviation_is_ready(struct MedianAbsoluteDeviation *handle);

const char *wickra_median_absolute_deviation_name(struct MedianAbsoluteDeviation *handle);

void wickra_median_absolute_deviation_reset(struct MedianAbsoluteDeviation *handle);

void wickra_median_absolute_deviation_free(struct MedianAbsoluteDeviation *handle);

struct MedianMa *wickra_median_ma_new(uintptr_t period);

double wickra_median_ma_update(struct MedianMa *handle, double value);

void wickra_median_ma_batch(struct MedianMa *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_median_ma_warmup_period(struct MedianMa *handle);

bool wickra_median_ma_is_ready(struct MedianMa *handle);

const char *wickra_median_ma_name(struct MedianMa *handle);

void wickra_median_ma_reset(struct MedianMa *handle);

void wickra_median_ma_free(struct MedianMa *handle);

struct MidPoint *wickra_mid_point_new(uintptr_t period);

double wickra_mid_point_update(struct MidPoint *handle, double value);

void wickra_mid_point_batch(struct MidPoint *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_mid_point_warmup_period(struct MidPoint *handle);

bool wickra_mid_point_is_ready(struct MidPoint *handle);

const char *wickra_mid_point_name(struct MidPoint *handle);

void wickra_mid_point_reset(struct MidPoint *handle);

void wickra_mid_point_free(struct MidPoint *handle);

struct Mom *wickra_mom_new(uintptr_t period);

double wickra_mom_update(struct Mom *handle, double value);

void wickra_mom_batch(struct Mom *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_mom_warmup_period(struct Mom *handle);

bool wickra_mom_is_ready(struct Mom *handle);

const char *wickra_mom_name(struct Mom *handle);

void wickra_mom_reset(struct Mom *handle);

void wickra_mom_free(struct Mom *handle);

struct OmegaRatio *wickra_omega_ratio_new(uintptr_t period, double threshold);

double wickra_omega_ratio_update(struct OmegaRatio *handle, double value);

void wickra_omega_ratio_batch(struct OmegaRatio *handle,
                              const double *input,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_omega_ratio_warmup_period(struct OmegaRatio *handle);

bool wickra_omega_ratio_is_ready(struct OmegaRatio *handle);

const char *wickra_omega_ratio_name(struct OmegaRatio *handle);

void wickra_omega_ratio_reset(struct OmegaRatio *handle);

void wickra_omega_ratio_free(struct OmegaRatio *handle);

struct PainIndex *wickra_pain_index_new(uintptr_t period);

double wickra_pain_index_update(struct PainIndex *handle, double value);

void wickra_pain_index_batch(struct PainIndex *handle,
                             const double *input,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_pain_index_warmup_period(struct PainIndex *handle);

bool wickra_pain_index_is_ready(struct PainIndex *handle);

const char *wickra_pain_index_name(struct PainIndex *handle);

void wickra_pain_index_reset(struct PainIndex *handle);

void wickra_pain_index_free(struct PainIndex *handle);

struct PercentB *wickra_percent_b_new(uintptr_t period, double multiplier);

double wickra_percent_b_update(struct PercentB *handle, double value);

void wickra_percent_b_batch(struct PercentB *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_percent_b_warmup_period(struct PercentB *handle);

bool wickra_percent_b_is_ready(struct PercentB *handle);

const char *wickra_percent_b_name(struct PercentB *handle);

void wickra_percent_b_reset(struct PercentB *handle);

void wickra_percent_b_free(struct PercentB *handle);

struct PercentageTrailingStop *wickra_percentage_trailing_stop_new(double percent);

double wickra_percentage_trailing_stop_update(struct PercentageTrailingStop *handle, double value);

void wickra_percentage_trailing_stop_batch(struct PercentageTrailingStop *handle,
                                           const double *input,
                                           double *out,
                                           uintptr_t n);

uintptr_t wickra_percentage_trailing_stop_warmup_period(struct PercentageTrailingStop *handle);

bool wickra_percentage_trailing_stop_is_ready(struct PercentageTrailingStop *handle);

const char *wickra_percentage_trailing_stop_name(struct PercentageTrailingStop *handle);

void wickra_percentage_trailing_stop_reset(struct PercentageTrailingStop *handle);

void wickra_percentage_trailing_stop_free(struct PercentageTrailingStop *handle);

struct Pmo *wickra_pmo_new(uintptr_t smoothing1, uintptr_t smoothing2);

double wickra_pmo_update(struct Pmo *handle, double value);

void wickra_pmo_batch(struct Pmo *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_pmo_warmup_period(struct Pmo *handle);

bool wickra_pmo_is_ready(struct Pmo *handle);

const char *wickra_pmo_name(struct Pmo *handle);

void wickra_pmo_reset(struct Pmo *handle);

void wickra_pmo_free(struct Pmo *handle);

struct PolarizedFractalEfficiency *wickra_polarized_fractal_efficiency_new(uintptr_t period,
                                                                           uintptr_t smoothing);

double wickra_polarized_fractal_efficiency_update(struct PolarizedFractalEfficiency *handle,
                                                  double value);

void wickra_polarized_fractal_efficiency_batch(struct PolarizedFractalEfficiency *handle,
                                               const double *input,
                                               double *out,
                                               uintptr_t n);

uintptr_t wickra_polarized_fractal_efficiency_warmup_period(struct PolarizedFractalEfficiency *handle);

bool wickra_polarized_fractal_efficiency_is_ready(struct PolarizedFractalEfficiency *handle);

const char *wickra_polarized_fractal_efficiency_name(struct PolarizedFractalEfficiency *handle);

void wickra_polarized_fractal_efficiency_reset(struct PolarizedFractalEfficiency *handle);

void wickra_polarized_fractal_efficiency_free(struct PolarizedFractalEfficiency *handle);

struct Ppo *wickra_ppo_new(uintptr_t fast, uintptr_t slow);

double wickra_ppo_update(struct Ppo *handle, double value);

void wickra_ppo_batch(struct Ppo *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_ppo_warmup_period(struct Ppo *handle);

bool wickra_ppo_is_ready(struct Ppo *handle);

const char *wickra_ppo_name(struct Ppo *handle);

void wickra_ppo_reset(struct Ppo *handle);

void wickra_ppo_free(struct Ppo *handle);

struct PpoHistogram *wickra_ppo_histogram_new(uintptr_t fast, uintptr_t slow, uintptr_t signal);

double wickra_ppo_histogram_update(struct PpoHistogram *handle, double value);

void wickra_ppo_histogram_batch(struct PpoHistogram *handle,
                                const double *input,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_ppo_histogram_warmup_period(struct PpoHistogram *handle);

bool wickra_ppo_histogram_is_ready(struct PpoHistogram *handle);

const char *wickra_ppo_histogram_name(struct PpoHistogram *handle);

void wickra_ppo_histogram_reset(struct PpoHistogram *handle);

void wickra_ppo_histogram_free(struct PpoHistogram *handle);

struct ProfitFactor *wickra_profit_factor_new(uintptr_t period);

double wickra_profit_factor_update(struct ProfitFactor *handle, double value);

void wickra_profit_factor_batch(struct ProfitFactor *handle,
                                const double *input,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_profit_factor_warmup_period(struct ProfitFactor *handle);

bool wickra_profit_factor_is_ready(struct ProfitFactor *handle);

const char *wickra_profit_factor_name(struct ProfitFactor *handle);

void wickra_profit_factor_reset(struct ProfitFactor *handle);

void wickra_profit_factor_free(struct ProfitFactor *handle);

struct RSquared *wickra_r_squared_new(uintptr_t period);

double wickra_r_squared_update(struct RSquared *handle, double value);

void wickra_r_squared_batch(struct RSquared *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_r_squared_warmup_period(struct RSquared *handle);

bool wickra_r_squared_is_ready(struct RSquared *handle);

const char *wickra_r_squared_name(struct RSquared *handle);

void wickra_r_squared_reset(struct RSquared *handle);

void wickra_r_squared_free(struct RSquared *handle);

struct RealizedVolatility *wickra_realized_volatility_new(uintptr_t period);

double wickra_realized_volatility_update(struct RealizedVolatility *handle, double value);

void wickra_realized_volatility_batch(struct RealizedVolatility *handle,
                                      const double *input,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_realized_volatility_warmup_period(struct RealizedVolatility *handle);

bool wickra_realized_volatility_is_ready(struct RealizedVolatility *handle);

const char *wickra_realized_volatility_name(struct RealizedVolatility *handle);

void wickra_realized_volatility_reset(struct RealizedVolatility *handle);

void wickra_realized_volatility_free(struct RealizedVolatility *handle);

struct RecoveryFactor *wickra_recovery_factor_new(void);

double wickra_recovery_factor_update(struct RecoveryFactor *handle, double value);

void wickra_recovery_factor_batch(struct RecoveryFactor *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_recovery_factor_warmup_period(struct RecoveryFactor *handle);

bool wickra_recovery_factor_is_ready(struct RecoveryFactor *handle);

const char *wickra_recovery_factor_name(struct RecoveryFactor *handle);

void wickra_recovery_factor_reset(struct RecoveryFactor *handle);

void wickra_recovery_factor_free(struct RecoveryFactor *handle);

struct Reflex *wickra_reflex_new(uintptr_t period);

double wickra_reflex_update(struct Reflex *handle, double value);

void wickra_reflex_batch(struct Reflex *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_reflex_warmup_period(struct Reflex *handle);

bool wickra_reflex_is_ready(struct Reflex *handle);

const char *wickra_reflex_name(struct Reflex *handle);

void wickra_reflex_reset(struct Reflex *handle);

void wickra_reflex_free(struct Reflex *handle);

struct RegimeLabel *wickra_regime_label_new(uintptr_t vol_period, uintptr_t lookback);

double wickra_regime_label_update(struct RegimeLabel *handle, double value);

void wickra_regime_label_batch(struct RegimeLabel *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_regime_label_warmup_period(struct RegimeLabel *handle);

bool wickra_regime_label_is_ready(struct RegimeLabel *handle);

const char *wickra_regime_label_name(struct RegimeLabel *handle);

void wickra_regime_label_reset(struct RegimeLabel *handle);

void wickra_regime_label_free(struct RegimeLabel *handle);

struct RenkoTrailingStop *wickra_renko_trailing_stop_new(double block_size);

double wickra_renko_trailing_stop_update(struct RenkoTrailingStop *handle, double value);

void wickra_renko_trailing_stop_batch(struct RenkoTrailingStop *handle,
                                      const double *input,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_renko_trailing_stop_warmup_period(struct RenkoTrailingStop *handle);

bool wickra_renko_trailing_stop_is_ready(struct RenkoTrailingStop *handle);

const char *wickra_renko_trailing_stop_name(struct RenkoTrailingStop *handle);

void wickra_renko_trailing_stop_reset(struct RenkoTrailingStop *handle);

void wickra_renko_trailing_stop_free(struct RenkoTrailingStop *handle);

struct Rmi *wickra_rmi_new(uintptr_t period, uintptr_t momentum);

double wickra_rmi_update(struct Rmi *handle, double value);

void wickra_rmi_batch(struct Rmi *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_rmi_warmup_period(struct Rmi *handle);

bool wickra_rmi_is_ready(struct Rmi *handle);

const char *wickra_rmi_name(struct Rmi *handle);

void wickra_rmi_reset(struct Rmi *handle);

void wickra_rmi_free(struct Rmi *handle);

struct Roc *wickra_roc_new(uintptr_t period);

double wickra_roc_update(struct Roc *handle, double value);

void wickra_roc_batch(struct Roc *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_roc_warmup_period(struct Roc *handle);

bool wickra_roc_is_ready(struct Roc *handle);

const char *wickra_roc_name(struct Roc *handle);

void wickra_roc_reset(struct Roc *handle);

void wickra_roc_free(struct Roc *handle);

struct Rocp *wickra_rocp_new(uintptr_t period);

double wickra_rocp_update(struct Rocp *handle, double value);

void wickra_rocp_batch(struct Rocp *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_rocp_warmup_period(struct Rocp *handle);

bool wickra_rocp_is_ready(struct Rocp *handle);

const char *wickra_rocp_name(struct Rocp *handle);

void wickra_rocp_reset(struct Rocp *handle);

void wickra_rocp_free(struct Rocp *handle);

struct Rocr *wickra_rocr_new(uintptr_t period);

double wickra_rocr_update(struct Rocr *handle, double value);

void wickra_rocr_batch(struct Rocr *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_rocr_warmup_period(struct Rocr *handle);

bool wickra_rocr_is_ready(struct Rocr *handle);

const char *wickra_rocr_name(struct Rocr *handle);

void wickra_rocr_reset(struct Rocr *handle);

void wickra_rocr_free(struct Rocr *handle);

struct Rocr100 *wickra_rocr100_new(uintptr_t period);

double wickra_rocr100_update(struct Rocr100 *handle, double value);

void wickra_rocr100_batch(struct Rocr100 *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_rocr100_warmup_period(struct Rocr100 *handle);

bool wickra_rocr100_is_ready(struct Rocr100 *handle);

const char *wickra_rocr100_name(struct Rocr100 *handle);

void wickra_rocr100_reset(struct Rocr100 *handle);

void wickra_rocr100_free(struct Rocr100 *handle);

struct RollingIqr *wickra_rolling_iqr_new(uintptr_t period);

double wickra_rolling_iqr_update(struct RollingIqr *handle, double value);

void wickra_rolling_iqr_batch(struct RollingIqr *handle,
                              const double *input,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_rolling_iqr_warmup_period(struct RollingIqr *handle);

bool wickra_rolling_iqr_is_ready(struct RollingIqr *handle);

const char *wickra_rolling_iqr_name(struct RollingIqr *handle);

void wickra_rolling_iqr_reset(struct RollingIqr *handle);

void wickra_rolling_iqr_free(struct RollingIqr *handle);

struct RollingMinMaxScaler *wickra_rolling_min_max_scaler_new(uintptr_t period);

double wickra_rolling_min_max_scaler_update(struct RollingMinMaxScaler *handle, double value);

void wickra_rolling_min_max_scaler_batch(struct RollingMinMaxScaler *handle,
                                         const double *input,
                                         double *out,
                                         uintptr_t n);

uintptr_t wickra_rolling_min_max_scaler_warmup_period(struct RollingMinMaxScaler *handle);

bool wickra_rolling_min_max_scaler_is_ready(struct RollingMinMaxScaler *handle);

const char *wickra_rolling_min_max_scaler_name(struct RollingMinMaxScaler *handle);

void wickra_rolling_min_max_scaler_reset(struct RollingMinMaxScaler *handle);

void wickra_rolling_min_max_scaler_free(struct RollingMinMaxScaler *handle);

struct RollingPercentileRank *wickra_rolling_percentile_rank_new(uintptr_t period);

double wickra_rolling_percentile_rank_update(struct RollingPercentileRank *handle, double value);

void wickra_rolling_percentile_rank_batch(struct RollingPercentileRank *handle,
                                          const double *input,
                                          double *out,
                                          uintptr_t n);

uintptr_t wickra_rolling_percentile_rank_warmup_period(struct RollingPercentileRank *handle);

bool wickra_rolling_percentile_rank_is_ready(struct RollingPercentileRank *handle);

const char *wickra_rolling_percentile_rank_name(struct RollingPercentileRank *handle);

void wickra_rolling_percentile_rank_reset(struct RollingPercentileRank *handle);

void wickra_rolling_percentile_rank_free(struct RollingPercentileRank *handle);

struct RollingQuantile *wickra_rolling_quantile_new(uintptr_t period, double quantile);

double wickra_rolling_quantile_update(struct RollingQuantile *handle, double value);

void wickra_rolling_quantile_batch(struct RollingQuantile *handle,
                                   const double *input,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_rolling_quantile_warmup_period(struct RollingQuantile *handle);

bool wickra_rolling_quantile_is_ready(struct RollingQuantile *handle);

const char *wickra_rolling_quantile_name(struct RollingQuantile *handle);

void wickra_rolling_quantile_reset(struct RollingQuantile *handle);

void wickra_rolling_quantile_free(struct RollingQuantile *handle);

struct RoofingFilter *wickra_roofing_filter_new(uintptr_t lp_period, uintptr_t hp_period);

double wickra_roofing_filter_update(struct RoofingFilter *handle, double value);

void wickra_roofing_filter_batch(struct RoofingFilter *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_roofing_filter_warmup_period(struct RoofingFilter *handle);

bool wickra_roofing_filter_is_ready(struct RoofingFilter *handle);

const char *wickra_roofing_filter_name(struct RoofingFilter *handle);

void wickra_roofing_filter_reset(struct RoofingFilter *handle);

void wickra_roofing_filter_free(struct RoofingFilter *handle);

struct Rsi *wickra_rsi_new(uintptr_t period);

double wickra_rsi_update(struct Rsi *handle, double value);

void wickra_rsi_batch(struct Rsi *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_rsi_warmup_period(struct Rsi *handle);

bool wickra_rsi_is_ready(struct Rsi *handle);

const char *wickra_rsi_name(struct Rsi *handle);

void wickra_rsi_reset(struct Rsi *handle);

void wickra_rsi_free(struct Rsi *handle);

struct Rsx *wickra_rsx_new(uintptr_t length);

double wickra_rsx_update(struct Rsx *handle, double value);

void wickra_rsx_batch(struct Rsx *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_rsx_warmup_period(struct Rsx *handle);

bool wickra_rsx_is_ready(struct Rsx *handle);

const char *wickra_rsx_name(struct Rsx *handle);

void wickra_rsx_reset(struct Rsx *handle);

void wickra_rsx_free(struct Rsx *handle);

struct RviVolatility *wickra_rvi_volatility_new(uintptr_t period);

double wickra_rvi_volatility_update(struct RviVolatility *handle, double value);

void wickra_rvi_volatility_batch(struct RviVolatility *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_rvi_volatility_warmup_period(struct RviVolatility *handle);

bool wickra_rvi_volatility_is_ready(struct RviVolatility *handle);

const char *wickra_rvi_volatility_name(struct RviVolatility *handle);

void wickra_rvi_volatility_reset(struct RviVolatility *handle);

void wickra_rvi_volatility_free(struct RviVolatility *handle);

struct SampleEntropy *wickra_sample_entropy_new(uintptr_t period, uintptr_t m, double r_factor);

double wickra_sample_entropy_update(struct SampleEntropy *handle, double value);

void wickra_sample_entropy_batch(struct SampleEntropy *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_sample_entropy_warmup_period(struct SampleEntropy *handle);

bool wickra_sample_entropy_is_ready(struct SampleEntropy *handle);

const char *wickra_sample_entropy_name(struct SampleEntropy *handle);

void wickra_sample_entropy_reset(struct SampleEntropy *handle);

void wickra_sample_entropy_free(struct SampleEntropy *handle);

struct ShannonEntropy *wickra_shannon_entropy_new(uintptr_t period, uintptr_t bins);

double wickra_shannon_entropy_update(struct ShannonEntropy *handle, double value);

void wickra_shannon_entropy_batch(struct ShannonEntropy *handle,
                                  const double *input,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_shannon_entropy_warmup_period(struct ShannonEntropy *handle);

bool wickra_shannon_entropy_is_ready(struct ShannonEntropy *handle);

const char *wickra_shannon_entropy_name(struct ShannonEntropy *handle);

void wickra_shannon_entropy_reset(struct ShannonEntropy *handle);

void wickra_shannon_entropy_free(struct ShannonEntropy *handle);

struct SharpeRatio *wickra_sharpe_ratio_new(uintptr_t period, double risk_free);

double wickra_sharpe_ratio_update(struct SharpeRatio *handle, double value);

void wickra_sharpe_ratio_batch(struct SharpeRatio *handle,
                               const double *input,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_sharpe_ratio_warmup_period(struct SharpeRatio *handle);

bool wickra_sharpe_ratio_is_ready(struct SharpeRatio *handle);

const char *wickra_sharpe_ratio_name(struct SharpeRatio *handle);

void wickra_sharpe_ratio_reset(struct SharpeRatio *handle);

void wickra_sharpe_ratio_free(struct SharpeRatio *handle);

struct SineWave *wickra_sine_wave_new(void);

double wickra_sine_wave_update(struct SineWave *handle, double value);

void wickra_sine_wave_batch(struct SineWave *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_sine_wave_warmup_period(struct SineWave *handle);

bool wickra_sine_wave_is_ready(struct SineWave *handle);

const char *wickra_sine_wave_name(struct SineWave *handle);

void wickra_sine_wave_reset(struct SineWave *handle);

void wickra_sine_wave_free(struct SineWave *handle);

struct SineWeightedMa *wickra_sine_weighted_ma_new(uintptr_t period);

double wickra_sine_weighted_ma_update(struct SineWeightedMa *handle, double value);

void wickra_sine_weighted_ma_batch(struct SineWeightedMa *handle,
                                   const double *input,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_sine_weighted_ma_warmup_period(struct SineWeightedMa *handle);

bool wickra_sine_weighted_ma_is_ready(struct SineWeightedMa *handle);

const char *wickra_sine_weighted_ma_name(struct SineWeightedMa *handle);

void wickra_sine_weighted_ma_reset(struct SineWeightedMa *handle);

void wickra_sine_weighted_ma_free(struct SineWeightedMa *handle);

struct Skewness *wickra_skewness_new(uintptr_t period);

double wickra_skewness_update(struct Skewness *handle, double value);

void wickra_skewness_batch(struct Skewness *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_skewness_warmup_period(struct Skewness *handle);

bool wickra_skewness_is_ready(struct Skewness *handle);

const char *wickra_skewness_name(struct Skewness *handle);

void wickra_skewness_reset(struct Skewness *handle);

void wickra_skewness_free(struct Skewness *handle);

struct Sma *wickra_sma_new(uintptr_t period);

double wickra_sma_update(struct Sma *handle, double value);

void wickra_sma_batch(struct Sma *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_sma_warmup_period(struct Sma *handle);

bool wickra_sma_is_ready(struct Sma *handle);

const char *wickra_sma_name(struct Sma *handle);

void wickra_sma_reset(struct Sma *handle);

void wickra_sma_free(struct Sma *handle);

struct Smma *wickra_smma_new(uintptr_t period);

double wickra_smma_update(struct Smma *handle, double value);

void wickra_smma_batch(struct Smma *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_smma_warmup_period(struct Smma *handle);

bool wickra_smma_is_ready(struct Smma *handle);

const char *wickra_smma_name(struct Smma *handle);

void wickra_smma_reset(struct Smma *handle);

void wickra_smma_free(struct Smma *handle);

struct SortinoRatio *wickra_sortino_ratio_new(uintptr_t period, double mar);

double wickra_sortino_ratio_update(struct SortinoRatio *handle, double value);

void wickra_sortino_ratio_batch(struct SortinoRatio *handle,
                                const double *input,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_sortino_ratio_warmup_period(struct SortinoRatio *handle);

bool wickra_sortino_ratio_is_ready(struct SortinoRatio *handle);

const char *wickra_sortino_ratio_name(struct SortinoRatio *handle);

void wickra_sortino_ratio_reset(struct SortinoRatio *handle);

void wickra_sortino_ratio_free(struct SortinoRatio *handle);

struct StandardError *wickra_standard_error_new(uintptr_t period);

double wickra_standard_error_update(struct StandardError *handle, double value);

void wickra_standard_error_batch(struct StandardError *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_standard_error_warmup_period(struct StandardError *handle);

bool wickra_standard_error_is_ready(struct StandardError *handle);

const char *wickra_standard_error_name(struct StandardError *handle);

void wickra_standard_error_reset(struct StandardError *handle);

void wickra_standard_error_free(struct StandardError *handle);

struct Stc *wickra_stc_new(uintptr_t fast, uintptr_t slow, uintptr_t schaff_period, double factor);

double wickra_stc_update(struct Stc *handle, double value);

void wickra_stc_batch(struct Stc *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_stc_warmup_period(struct Stc *handle);

bool wickra_stc_is_ready(struct Stc *handle);

const char *wickra_stc_name(struct Stc *handle);

void wickra_stc_reset(struct Stc *handle);

void wickra_stc_free(struct Stc *handle);

struct StdDev *wickra_std_dev_new(uintptr_t period);

double wickra_std_dev_update(struct StdDev *handle, double value);

void wickra_std_dev_batch(struct StdDev *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_std_dev_warmup_period(struct StdDev *handle);

bool wickra_std_dev_is_ready(struct StdDev *handle);

const char *wickra_std_dev_name(struct StdDev *handle);

void wickra_std_dev_reset(struct StdDev *handle);

void wickra_std_dev_free(struct StdDev *handle);

struct StepTrailingStop *wickra_step_trailing_stop_new(double step_size);

double wickra_step_trailing_stop_update(struct StepTrailingStop *handle, double value);

void wickra_step_trailing_stop_batch(struct StepTrailingStop *handle,
                                     const double *input,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_step_trailing_stop_warmup_period(struct StepTrailingStop *handle);

bool wickra_step_trailing_stop_is_ready(struct StepTrailingStop *handle);

const char *wickra_step_trailing_stop_name(struct StepTrailingStop *handle);

void wickra_step_trailing_stop_reset(struct StepTrailingStop *handle);

void wickra_step_trailing_stop_free(struct StepTrailingStop *handle);

struct SterlingRatio *wickra_sterling_ratio_new(uintptr_t period);

double wickra_sterling_ratio_update(struct SterlingRatio *handle, double value);

void wickra_sterling_ratio_batch(struct SterlingRatio *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_sterling_ratio_warmup_period(struct SterlingRatio *handle);

bool wickra_sterling_ratio_is_ready(struct SterlingRatio *handle);

const char *wickra_sterling_ratio_name(struct SterlingRatio *handle);

void wickra_sterling_ratio_reset(struct SterlingRatio *handle);

void wickra_sterling_ratio_free(struct SterlingRatio *handle);

struct StochRsi *wickra_stoch_rsi_new(uintptr_t rsi_period, uintptr_t stoch_period);

double wickra_stoch_rsi_update(struct StochRsi *handle, double value);

void wickra_stoch_rsi_batch(struct StochRsi *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_stoch_rsi_warmup_period(struct StochRsi *handle);

bool wickra_stoch_rsi_is_ready(struct StochRsi *handle);

const char *wickra_stoch_rsi_name(struct StochRsi *handle);

void wickra_stoch_rsi_reset(struct StochRsi *handle);

void wickra_stoch_rsi_free(struct StochRsi *handle);

struct SuperSmoother *wickra_super_smoother_new(uintptr_t period);

double wickra_super_smoother_update(struct SuperSmoother *handle, double value);

void wickra_super_smoother_batch(struct SuperSmoother *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_super_smoother_warmup_period(struct SuperSmoother *handle);

bool wickra_super_smoother_is_ready(struct SuperSmoother *handle);

const char *wickra_super_smoother_name(struct SuperSmoother *handle);

void wickra_super_smoother_reset(struct SuperSmoother *handle);

void wickra_super_smoother_free(struct SuperSmoother *handle);

struct T3 *wickra_t3_new(uintptr_t period, double v);

double wickra_t3_update(struct T3 *handle, double value);

void wickra_t3_batch(struct T3 *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_t3_warmup_period(struct T3 *handle);

bool wickra_t3_is_ready(struct T3 *handle);

const char *wickra_t3_name(struct T3 *handle);

void wickra_t3_reset(struct T3 *handle);

void wickra_t3_free(struct T3 *handle);

struct TailRatio *wickra_tail_ratio_new(uintptr_t period);

double wickra_tail_ratio_update(struct TailRatio *handle, double value);

void wickra_tail_ratio_batch(struct TailRatio *handle,
                             const double *input,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_tail_ratio_warmup_period(struct TailRatio *handle);

bool wickra_tail_ratio_is_ready(struct TailRatio *handle);

const char *wickra_tail_ratio_name(struct TailRatio *handle);

void wickra_tail_ratio_reset(struct TailRatio *handle);

void wickra_tail_ratio_free(struct TailRatio *handle);

struct Tema *wickra_tema_new(uintptr_t period);

double wickra_tema_update(struct Tema *handle, double value);

void wickra_tema_batch(struct Tema *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_tema_warmup_period(struct Tema *handle);

bool wickra_tema_is_ready(struct Tema *handle);

const char *wickra_tema_name(struct Tema *handle);

void wickra_tema_reset(struct Tema *handle);

void wickra_tema_free(struct Tema *handle);

struct Tii *wickra_tii_new(uintptr_t sma_period, uintptr_t dev_period);

double wickra_tii_update(struct Tii *handle, double value);

void wickra_tii_batch(struct Tii *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_tii_warmup_period(struct Tii *handle);

bool wickra_tii_is_ready(struct Tii *handle);

const char *wickra_tii_name(struct Tii *handle);

void wickra_tii_reset(struct Tii *handle);

void wickra_tii_free(struct Tii *handle);

struct TrendLabel *wickra_trend_label_new(uintptr_t period);

double wickra_trend_label_update(struct TrendLabel *handle, double value);

void wickra_trend_label_batch(struct TrendLabel *handle,
                              const double *input,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_trend_label_warmup_period(struct TrendLabel *handle);

bool wickra_trend_label_is_ready(struct TrendLabel *handle);

const char *wickra_trend_label_name(struct TrendLabel *handle);

void wickra_trend_label_reset(struct TrendLabel *handle);

void wickra_trend_label_free(struct TrendLabel *handle);

struct TrendStrengthIndex *wickra_trend_strength_index_new(uintptr_t period);

double wickra_trend_strength_index_update(struct TrendStrengthIndex *handle, double value);

void wickra_trend_strength_index_batch(struct TrendStrengthIndex *handle,
                                       const double *input,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_trend_strength_index_warmup_period(struct TrendStrengthIndex *handle);

bool wickra_trend_strength_index_is_ready(struct TrendStrengthIndex *handle);

const char *wickra_trend_strength_index_name(struct TrendStrengthIndex *handle);

void wickra_trend_strength_index_reset(struct TrendStrengthIndex *handle);

void wickra_trend_strength_index_free(struct TrendStrengthIndex *handle);

struct Trendflex *wickra_trendflex_new(uintptr_t period);

double wickra_trendflex_update(struct Trendflex *handle, double value);

void wickra_trendflex_batch(struct Trendflex *handle,
                            const double *input,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_trendflex_warmup_period(struct Trendflex *handle);

bool wickra_trendflex_is_ready(struct Trendflex *handle);

const char *wickra_trendflex_name(struct Trendflex *handle);

void wickra_trendflex_reset(struct Trendflex *handle);

void wickra_trendflex_free(struct Trendflex *handle);

struct Trima *wickra_trima_new(uintptr_t period);

double wickra_trima_update(struct Trima *handle, double value);

void wickra_trima_batch(struct Trima *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_trima_warmup_period(struct Trima *handle);

bool wickra_trima_is_ready(struct Trima *handle);

const char *wickra_trima_name(struct Trima *handle);

void wickra_trima_reset(struct Trima *handle);

void wickra_trima_free(struct Trima *handle);

struct Trix *wickra_trix_new(uintptr_t period);

double wickra_trix_update(struct Trix *handle, double value);

void wickra_trix_batch(struct Trix *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_trix_warmup_period(struct Trix *handle);

bool wickra_trix_is_ready(struct Trix *handle);

const char *wickra_trix_name(struct Trix *handle);

void wickra_trix_reset(struct Trix *handle);

void wickra_trix_free(struct Trix *handle);

struct Tsf *wickra_tsf_new(uintptr_t period);

double wickra_tsf_update(struct Tsf *handle, double value);

void wickra_tsf_batch(struct Tsf *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_tsf_warmup_period(struct Tsf *handle);

bool wickra_tsf_is_ready(struct Tsf *handle);

const char *wickra_tsf_name(struct Tsf *handle);

void wickra_tsf_reset(struct Tsf *handle);

void wickra_tsf_free(struct Tsf *handle);

struct TsfOscillator *wickra_tsf_oscillator_new(uintptr_t period);

double wickra_tsf_oscillator_update(struct TsfOscillator *handle, double value);

void wickra_tsf_oscillator_batch(struct TsfOscillator *handle,
                                 const double *input,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_tsf_oscillator_warmup_period(struct TsfOscillator *handle);

bool wickra_tsf_oscillator_is_ready(struct TsfOscillator *handle);

const char *wickra_tsf_oscillator_name(struct TsfOscillator *handle);

void wickra_tsf_oscillator_reset(struct TsfOscillator *handle);

void wickra_tsf_oscillator_free(struct TsfOscillator *handle);

struct Tsi *wickra_tsi_new(uintptr_t long_, uintptr_t short_);

double wickra_tsi_update(struct Tsi *handle, double value);

void wickra_tsi_batch(struct Tsi *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_tsi_warmup_period(struct Tsi *handle);

bool wickra_tsi_is_ready(struct Tsi *handle);

const char *wickra_tsi_name(struct Tsi *handle);

void wickra_tsi_reset(struct Tsi *handle);

void wickra_tsi_free(struct Tsi *handle);

struct UlcerIndex *wickra_ulcer_index_new(uintptr_t period);

double wickra_ulcer_index_update(struct UlcerIndex *handle, double value);

void wickra_ulcer_index_batch(struct UlcerIndex *handle,
                              const double *input,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_ulcer_index_warmup_period(struct UlcerIndex *handle);

bool wickra_ulcer_index_is_ready(struct UlcerIndex *handle);

const char *wickra_ulcer_index_name(struct UlcerIndex *handle);

void wickra_ulcer_index_reset(struct UlcerIndex *handle);

void wickra_ulcer_index_free(struct UlcerIndex *handle);

struct UniversalOscillator *wickra_universal_oscillator_new(uintptr_t period);

double wickra_universal_oscillator_update(struct UniversalOscillator *handle, double value);

void wickra_universal_oscillator_batch(struct UniversalOscillator *handle,
                                       const double *input,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_universal_oscillator_warmup_period(struct UniversalOscillator *handle);

bool wickra_universal_oscillator_is_ready(struct UniversalOscillator *handle);

const char *wickra_universal_oscillator_name(struct UniversalOscillator *handle);

void wickra_universal_oscillator_reset(struct UniversalOscillator *handle);

void wickra_universal_oscillator_free(struct UniversalOscillator *handle);

struct UpsidePotentialRatio *wickra_upside_potential_ratio_new(uintptr_t period, double mar);

double wickra_upside_potential_ratio_update(struct UpsidePotentialRatio *handle, double value);

void wickra_upside_potential_ratio_batch(struct UpsidePotentialRatio *handle,
                                         const double *input,
                                         double *out,
                                         uintptr_t n);

uintptr_t wickra_upside_potential_ratio_warmup_period(struct UpsidePotentialRatio *handle);

bool wickra_upside_potential_ratio_is_ready(struct UpsidePotentialRatio *handle);

const char *wickra_upside_potential_ratio_name(struct UpsidePotentialRatio *handle);

void wickra_upside_potential_ratio_reset(struct UpsidePotentialRatio *handle);

void wickra_upside_potential_ratio_free(struct UpsidePotentialRatio *handle);

struct ValueAtRisk *wickra_value_at_risk_new(uintptr_t period, double confidence);

double wickra_value_at_risk_update(struct ValueAtRisk *handle, double value);

void wickra_value_at_risk_batch(struct ValueAtRisk *handle,
                                const double *input,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_value_at_risk_warmup_period(struct ValueAtRisk *handle);

bool wickra_value_at_risk_is_ready(struct ValueAtRisk *handle);

const char *wickra_value_at_risk_name(struct ValueAtRisk *handle);

void wickra_value_at_risk_reset(struct ValueAtRisk *handle);

void wickra_value_at_risk_free(struct ValueAtRisk *handle);

struct Variance *wickra_variance_new(uintptr_t period);

double wickra_variance_update(struct Variance *handle, double value);

void wickra_variance_batch(struct Variance *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_variance_warmup_period(struct Variance *handle);

bool wickra_variance_is_ready(struct Variance *handle);

const char *wickra_variance_name(struct Variance *handle);

void wickra_variance_reset(struct Variance *handle);

void wickra_variance_free(struct Variance *handle);

struct VerticalHorizontalFilter *wickra_vertical_horizontal_filter_new(uintptr_t period);

double wickra_vertical_horizontal_filter_update(struct VerticalHorizontalFilter *handle,
                                                double value);

void wickra_vertical_horizontal_filter_batch(struct VerticalHorizontalFilter *handle,
                                             const double *input,
                                             double *out,
                                             uintptr_t n);

uintptr_t wickra_vertical_horizontal_filter_warmup_period(struct VerticalHorizontalFilter *handle);

bool wickra_vertical_horizontal_filter_is_ready(struct VerticalHorizontalFilter *handle);

const char *wickra_vertical_horizontal_filter_name(struct VerticalHorizontalFilter *handle);

void wickra_vertical_horizontal_filter_reset(struct VerticalHorizontalFilter *handle);

void wickra_vertical_horizontal_filter_free(struct VerticalHorizontalFilter *handle);

struct Vidya *wickra_vidya_new(uintptr_t period, uintptr_t cmo_period);

double wickra_vidya_update(struct Vidya *handle, double value);

void wickra_vidya_batch(struct Vidya *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_vidya_warmup_period(struct Vidya *handle);

bool wickra_vidya_is_ready(struct Vidya *handle);

const char *wickra_vidya_name(struct Vidya *handle);

void wickra_vidya_reset(struct Vidya *handle);

void wickra_vidya_free(struct Vidya *handle);

struct VolatilityOfVolatility *wickra_volatility_of_volatility_new(uintptr_t vol_window,
                                                                   uintptr_t vov_window);

double wickra_volatility_of_volatility_update(struct VolatilityOfVolatility *handle, double value);

void wickra_volatility_of_volatility_batch(struct VolatilityOfVolatility *handle,
                                           const double *input,
                                           double *out,
                                           uintptr_t n);

uintptr_t wickra_volatility_of_volatility_warmup_period(struct VolatilityOfVolatility *handle);

bool wickra_volatility_of_volatility_is_ready(struct VolatilityOfVolatility *handle);

const char *wickra_volatility_of_volatility_name(struct VolatilityOfVolatility *handle);

void wickra_volatility_of_volatility_reset(struct VolatilityOfVolatility *handle);

void wickra_volatility_of_volatility_free(struct VolatilityOfVolatility *handle);

struct WavePm *wickra_wave_pm_new(uintptr_t length, uintptr_t smoothing);

double wickra_wave_pm_update(struct WavePm *handle, double value);

void wickra_wave_pm_batch(struct WavePm *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_wave_pm_warmup_period(struct WavePm *handle);

bool wickra_wave_pm_is_ready(struct WavePm *handle);

const char *wickra_wave_pm_name(struct WavePm *handle);

void wickra_wave_pm_reset(struct WavePm *handle);

void wickra_wave_pm_free(struct WavePm *handle);

struct WinRate *wickra_win_rate_new(uintptr_t period);

double wickra_win_rate_update(struct WinRate *handle, double value);

void wickra_win_rate_batch(struct WinRate *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_win_rate_warmup_period(struct WinRate *handle);

bool wickra_win_rate_is_ready(struct WinRate *handle);

const char *wickra_win_rate_name(struct WinRate *handle);

void wickra_win_rate_reset(struct WinRate *handle);

void wickra_win_rate_free(struct WinRate *handle);

struct Wma *wickra_wma_new(uintptr_t period);

double wickra_wma_update(struct Wma *handle, double value);

void wickra_wma_batch(struct Wma *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_wma_warmup_period(struct Wma *handle);

bool wickra_wma_is_ready(struct Wma *handle);

const char *wickra_wma_name(struct Wma *handle);

void wickra_wma_reset(struct Wma *handle);

void wickra_wma_free(struct Wma *handle);

struct ZScore *wickra_z_score_new(uintptr_t period);

double wickra_z_score_update(struct ZScore *handle, double value);

void wickra_z_score_batch(struct ZScore *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_z_score_warmup_period(struct ZScore *handle);

bool wickra_z_score_is_ready(struct ZScore *handle);

const char *wickra_z_score_name(struct ZScore *handle);

void wickra_z_score_reset(struct ZScore *handle);

void wickra_z_score_free(struct ZScore *handle);

struct Zlema *wickra_zlema_new(uintptr_t period);

double wickra_zlema_update(struct Zlema *handle, double value);

void wickra_zlema_batch(struct Zlema *handle, const double *input, double *out, uintptr_t n);

uintptr_t wickra_zlema_warmup_period(struct Zlema *handle);

bool wickra_zlema_is_ready(struct Zlema *handle);

const char *wickra_zlema_name(struct Zlema *handle);

void wickra_zlema_reset(struct Zlema *handle);

void wickra_zlema_free(struct Zlema *handle);

struct Alpha *wickra_alpha_new(uintptr_t period, double risk_free);

double wickra_alpha_update(struct Alpha *handle, double x, double y);

void wickra_alpha_batch(struct Alpha *handle,
                        const double *x,
                        const double *y,
                        double *out,
                        uintptr_t n);

uintptr_t wickra_alpha_warmup_period(struct Alpha *handle);

bool wickra_alpha_is_ready(struct Alpha *handle);

const char *wickra_alpha_name(struct Alpha *handle);

void wickra_alpha_reset(struct Alpha *handle);

void wickra_alpha_free(struct Alpha *handle);

struct Beta *wickra_beta_new(uintptr_t period);

double wickra_beta_update(struct Beta *handle, double x, double y);

void wickra_beta_batch(struct Beta *handle,
                       const double *x,
                       const double *y,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_beta_warmup_period(struct Beta *handle);

bool wickra_beta_is_ready(struct Beta *handle);

const char *wickra_beta_name(struct Beta *handle);

void wickra_beta_reset(struct Beta *handle);

void wickra_beta_free(struct Beta *handle);

struct BetaNeutralSpread *wickra_beta_neutral_spread_new(uintptr_t period);

double wickra_beta_neutral_spread_update(struct BetaNeutralSpread *handle, double x, double y);

void wickra_beta_neutral_spread_batch(struct BetaNeutralSpread *handle,
                                      const double *x,
                                      const double *y,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_beta_neutral_spread_warmup_period(struct BetaNeutralSpread *handle);

bool wickra_beta_neutral_spread_is_ready(struct BetaNeutralSpread *handle);

const char *wickra_beta_neutral_spread_name(struct BetaNeutralSpread *handle);

void wickra_beta_neutral_spread_reset(struct BetaNeutralSpread *handle);

void wickra_beta_neutral_spread_free(struct BetaNeutralSpread *handle);

struct DistanceSsd *wickra_distance_ssd_new(uintptr_t period);

double wickra_distance_ssd_update(struct DistanceSsd *handle, double x, double y);

void wickra_distance_ssd_batch(struct DistanceSsd *handle,
                               const double *x,
                               const double *y,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_distance_ssd_warmup_period(struct DistanceSsd *handle);

bool wickra_distance_ssd_is_ready(struct DistanceSsd *handle);

const char *wickra_distance_ssd_name(struct DistanceSsd *handle);

void wickra_distance_ssd_reset(struct DistanceSsd *handle);

void wickra_distance_ssd_free(struct DistanceSsd *handle);

struct GrangerCausality *wickra_granger_causality_new(uintptr_t period, uintptr_t lag);

double wickra_granger_causality_update(struct GrangerCausality *handle, double x, double y);

void wickra_granger_causality_batch(struct GrangerCausality *handle,
                                    const double *x,
                                    const double *y,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_granger_causality_warmup_period(struct GrangerCausality *handle);

bool wickra_granger_causality_is_ready(struct GrangerCausality *handle);

const char *wickra_granger_causality_name(struct GrangerCausality *handle);

void wickra_granger_causality_reset(struct GrangerCausality *handle);

void wickra_granger_causality_free(struct GrangerCausality *handle);

struct HasbrouckInformationShare *wickra_hasbrouck_information_share_new(uintptr_t period);

double wickra_hasbrouck_information_share_update(struct HasbrouckInformationShare *handle,
                                                 double x,
                                                 double y);

void wickra_hasbrouck_information_share_batch(struct HasbrouckInformationShare *handle,
                                              const double *x,
                                              const double *y,
                                              double *out,
                                              uintptr_t n);

uintptr_t wickra_hasbrouck_information_share_warmup_period(struct HasbrouckInformationShare *handle);

bool wickra_hasbrouck_information_share_is_ready(struct HasbrouckInformationShare *handle);

const char *wickra_hasbrouck_information_share_name(struct HasbrouckInformationShare *handle);

void wickra_hasbrouck_information_share_reset(struct HasbrouckInformationShare *handle);

void wickra_hasbrouck_information_share_free(struct HasbrouckInformationShare *handle);

struct InformationRatio *wickra_information_ratio_new(uintptr_t period);

double wickra_information_ratio_update(struct InformationRatio *handle, double x, double y);

void wickra_information_ratio_batch(struct InformationRatio *handle,
                                    const double *x,
                                    const double *y,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_information_ratio_warmup_period(struct InformationRatio *handle);

bool wickra_information_ratio_is_ready(struct InformationRatio *handle);

const char *wickra_information_ratio_name(struct InformationRatio *handle);

void wickra_information_ratio_reset(struct InformationRatio *handle);

void wickra_information_ratio_free(struct InformationRatio *handle);

struct KendallTau *wickra_kendall_tau_new(uintptr_t period);

double wickra_kendall_tau_update(struct KendallTau *handle, double x, double y);

void wickra_kendall_tau_batch(struct KendallTau *handle,
                              const double *x,
                              const double *y,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_kendall_tau_warmup_period(struct KendallTau *handle);

bool wickra_kendall_tau_is_ready(struct KendallTau *handle);

const char *wickra_kendall_tau_name(struct KendallTau *handle);

void wickra_kendall_tau_reset(struct KendallTau *handle);

void wickra_kendall_tau_free(struct KendallTau *handle);

struct OuHalfLife *wickra_ou_half_life_new(uintptr_t period);

double wickra_ou_half_life_update(struct OuHalfLife *handle, double x, double y);

void wickra_ou_half_life_batch(struct OuHalfLife *handle,
                               const double *x,
                               const double *y,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_ou_half_life_warmup_period(struct OuHalfLife *handle);

bool wickra_ou_half_life_is_ready(struct OuHalfLife *handle);

const char *wickra_ou_half_life_name(struct OuHalfLife *handle);

void wickra_ou_half_life_reset(struct OuHalfLife *handle);

void wickra_ou_half_life_free(struct OuHalfLife *handle);

struct PairSpreadZScore *wickra_pair_spread_z_score_new(uintptr_t beta_period, uintptr_t z_period);

double wickra_pair_spread_z_score_update(struct PairSpreadZScore *handle, double x, double y);

void wickra_pair_spread_z_score_batch(struct PairSpreadZScore *handle,
                                      const double *x,
                                      const double *y,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_pair_spread_z_score_warmup_period(struct PairSpreadZScore *handle);

bool wickra_pair_spread_z_score_is_ready(struct PairSpreadZScore *handle);

const char *wickra_pair_spread_z_score_name(struct PairSpreadZScore *handle);

void wickra_pair_spread_z_score_reset(struct PairSpreadZScore *handle);

void wickra_pair_spread_z_score_free(struct PairSpreadZScore *handle);

struct PairwiseBeta *wickra_pairwise_beta_new(uintptr_t period);

double wickra_pairwise_beta_update(struct PairwiseBeta *handle, double x, double y);

void wickra_pairwise_beta_batch(struct PairwiseBeta *handle,
                                const double *x,
                                const double *y,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_pairwise_beta_warmup_period(struct PairwiseBeta *handle);

bool wickra_pairwise_beta_is_ready(struct PairwiseBeta *handle);

const char *wickra_pairwise_beta_name(struct PairwiseBeta *handle);

void wickra_pairwise_beta_reset(struct PairwiseBeta *handle);

void wickra_pairwise_beta_free(struct PairwiseBeta *handle);

struct PearsonCorrelation *wickra_pearson_correlation_new(uintptr_t period);

double wickra_pearson_correlation_update(struct PearsonCorrelation *handle, double x, double y);

void wickra_pearson_correlation_batch(struct PearsonCorrelation *handle,
                                      const double *x,
                                      const double *y,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_pearson_correlation_warmup_period(struct PearsonCorrelation *handle);

bool wickra_pearson_correlation_is_ready(struct PearsonCorrelation *handle);

const char *wickra_pearson_correlation_name(struct PearsonCorrelation *handle);

void wickra_pearson_correlation_reset(struct PearsonCorrelation *handle);

void wickra_pearson_correlation_free(struct PearsonCorrelation *handle);

struct RollingCorrelation *wickra_rolling_correlation_new(uintptr_t period);

double wickra_rolling_correlation_update(struct RollingCorrelation *handle, double x, double y);

void wickra_rolling_correlation_batch(struct RollingCorrelation *handle,
                                      const double *x,
                                      const double *y,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_rolling_correlation_warmup_period(struct RollingCorrelation *handle);

bool wickra_rolling_correlation_is_ready(struct RollingCorrelation *handle);

const char *wickra_rolling_correlation_name(struct RollingCorrelation *handle);

void wickra_rolling_correlation_reset(struct RollingCorrelation *handle);

void wickra_rolling_correlation_free(struct RollingCorrelation *handle);

struct RollingCovariance *wickra_rolling_covariance_new(uintptr_t period);

double wickra_rolling_covariance_update(struct RollingCovariance *handle, double x, double y);

void wickra_rolling_covariance_batch(struct RollingCovariance *handle,
                                     const double *x,
                                     const double *y,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_rolling_covariance_warmup_period(struct RollingCovariance *handle);

bool wickra_rolling_covariance_is_ready(struct RollingCovariance *handle);

const char *wickra_rolling_covariance_name(struct RollingCovariance *handle);

void wickra_rolling_covariance_reset(struct RollingCovariance *handle);

void wickra_rolling_covariance_free(struct RollingCovariance *handle);

struct SpearmanCorrelation *wickra_spearman_correlation_new(uintptr_t period);

double wickra_spearman_correlation_update(struct SpearmanCorrelation *handle, double x, double y);

void wickra_spearman_correlation_batch(struct SpearmanCorrelation *handle,
                                       const double *x,
                                       const double *y,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_spearman_correlation_warmup_period(struct SpearmanCorrelation *handle);

bool wickra_spearman_correlation_is_ready(struct SpearmanCorrelation *handle);

const char *wickra_spearman_correlation_name(struct SpearmanCorrelation *handle);

void wickra_spearman_correlation_reset(struct SpearmanCorrelation *handle);

void wickra_spearman_correlation_free(struct SpearmanCorrelation *handle);

struct SpreadAr1Coefficient *wickra_spread_ar1_coefficient_new(uintptr_t period);

double wickra_spread_ar1_coefficient_update(struct SpreadAr1Coefficient *handle,
                                            double x,
                                            double y);

void wickra_spread_ar1_coefficient_batch(struct SpreadAr1Coefficient *handle,
                                         const double *x,
                                         const double *y,
                                         double *out,
                                         uintptr_t n);

uintptr_t wickra_spread_ar1_coefficient_warmup_period(struct SpreadAr1Coefficient *handle);

bool wickra_spread_ar1_coefficient_is_ready(struct SpreadAr1Coefficient *handle);

const char *wickra_spread_ar1_coefficient_name(struct SpreadAr1Coefficient *handle);

void wickra_spread_ar1_coefficient_reset(struct SpreadAr1Coefficient *handle);

void wickra_spread_ar1_coefficient_free(struct SpreadAr1Coefficient *handle);

struct SpreadHurst *wickra_spread_hurst_new(uintptr_t period);

double wickra_spread_hurst_update(struct SpreadHurst *handle, double x, double y);

void wickra_spread_hurst_batch(struct SpreadHurst *handle,
                               const double *x,
                               const double *y,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_spread_hurst_warmup_period(struct SpreadHurst *handle);

bool wickra_spread_hurst_is_ready(struct SpreadHurst *handle);

const char *wickra_spread_hurst_name(struct SpreadHurst *handle);

void wickra_spread_hurst_reset(struct SpreadHurst *handle);

void wickra_spread_hurst_free(struct SpreadHurst *handle);

struct TreynorRatio *wickra_treynor_ratio_new(uintptr_t period, double risk_free);

double wickra_treynor_ratio_update(struct TreynorRatio *handle, double x, double y);

void wickra_treynor_ratio_batch(struct TreynorRatio *handle,
                                const double *x,
                                const double *y,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_treynor_ratio_warmup_period(struct TreynorRatio *handle);

bool wickra_treynor_ratio_is_ready(struct TreynorRatio *handle);

const char *wickra_treynor_ratio_name(struct TreynorRatio *handle);

void wickra_treynor_ratio_reset(struct TreynorRatio *handle);

void wickra_treynor_ratio_free(struct TreynorRatio *handle);

struct VarianceRatio *wickra_variance_ratio_new(uintptr_t period, uintptr_t q);

double wickra_variance_ratio_update(struct VarianceRatio *handle, double x, double y);

void wickra_variance_ratio_batch(struct VarianceRatio *handle,
                                 const double *x,
                                 const double *y,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_variance_ratio_warmup_period(struct VarianceRatio *handle);

bool wickra_variance_ratio_is_ready(struct VarianceRatio *handle);

const char *wickra_variance_ratio_name(struct VarianceRatio *handle);

void wickra_variance_ratio_reset(struct VarianceRatio *handle);

void wickra_variance_ratio_free(struct VarianceRatio *handle);

struct AbandonedBaby *wickra_abandoned_baby_new(void);

double wickra_abandoned_baby_update(struct AbandonedBaby *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_abandoned_baby_batch(struct AbandonedBaby *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_abandoned_baby_warmup_period(struct AbandonedBaby *handle);

bool wickra_abandoned_baby_is_ready(struct AbandonedBaby *handle);

const char *wickra_abandoned_baby_name(struct AbandonedBaby *handle);

void wickra_abandoned_baby_reset(struct AbandonedBaby *handle);

void wickra_abandoned_baby_free(struct AbandonedBaby *handle);

struct Abcd *wickra_abcd_new(void);

double wickra_abcd_update(struct Abcd *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp);

void wickra_abcd_batch(struct Abcd *handle,
                       const double *open,
                       const double *high,
                       const double *low,
                       const double *close,
                       const double *volume,
                       const int64_t *timestamp,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_abcd_warmup_period(struct Abcd *handle);

bool wickra_abcd_is_ready(struct Abcd *handle);

const char *wickra_abcd_name(struct Abcd *handle);

void wickra_abcd_reset(struct Abcd *handle);

void wickra_abcd_free(struct Abcd *handle);

struct AcceleratorOscillator *wickra_accelerator_oscillator_new(uintptr_t ao_fast,
                                                                uintptr_t ao_slow,
                                                                uintptr_t signal_period);

double wickra_accelerator_oscillator_update(struct AcceleratorOscillator *handle,
                                            double open,
                                            double high,
                                            double low,
                                            double close,
                                            double volume,
                                            int64_t timestamp);

void wickra_accelerator_oscillator_batch(struct AcceleratorOscillator *handle,
                                         const double *open,
                                         const double *high,
                                         const double *low,
                                         const double *close,
                                         const double *volume,
                                         const int64_t *timestamp,
                                         double *out,
                                         uintptr_t n);

uintptr_t wickra_accelerator_oscillator_warmup_period(struct AcceleratorOscillator *handle);

bool wickra_accelerator_oscillator_is_ready(struct AcceleratorOscillator *handle);

const char *wickra_accelerator_oscillator_name(struct AcceleratorOscillator *handle);

void wickra_accelerator_oscillator_reset(struct AcceleratorOscillator *handle);

void wickra_accelerator_oscillator_free(struct AcceleratorOscillator *handle);

struct AdOscillator *wickra_ad_oscillator_new(void);

double wickra_ad_oscillator_update(struct AdOscillator *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_ad_oscillator_batch(struct AdOscillator *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_ad_oscillator_warmup_period(struct AdOscillator *handle);

bool wickra_ad_oscillator_is_ready(struct AdOscillator *handle);

const char *wickra_ad_oscillator_name(struct AdOscillator *handle);

void wickra_ad_oscillator_reset(struct AdOscillator *handle);

void wickra_ad_oscillator_free(struct AdOscillator *handle);

struct AdaptiveCci *wickra_adaptive_cci_new(uintptr_t period);

double wickra_adaptive_cci_update(struct AdaptiveCci *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_adaptive_cci_batch(struct AdaptiveCci *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_adaptive_cci_warmup_period(struct AdaptiveCci *handle);

bool wickra_adaptive_cci_is_ready(struct AdaptiveCci *handle);

const char *wickra_adaptive_cci_name(struct AdaptiveCci *handle);

void wickra_adaptive_cci_reset(struct AdaptiveCci *handle);

void wickra_adaptive_cci_free(struct AdaptiveCci *handle);

struct Adl *wickra_adl_new(void);

double wickra_adl_update(struct Adl *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_adl_batch(struct Adl *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_adl_warmup_period(struct Adl *handle);

bool wickra_adl_is_ready(struct Adl *handle);

const char *wickra_adl_name(struct Adl *handle);

void wickra_adl_reset(struct Adl *handle);

void wickra_adl_free(struct Adl *handle);

struct AdvanceBlock *wickra_advance_block_new(void);

double wickra_advance_block_update(struct AdvanceBlock *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_advance_block_batch(struct AdvanceBlock *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_advance_block_warmup_period(struct AdvanceBlock *handle);

bool wickra_advance_block_is_ready(struct AdvanceBlock *handle);

const char *wickra_advance_block_name(struct AdvanceBlock *handle);

void wickra_advance_block_reset(struct AdvanceBlock *handle);

void wickra_advance_block_free(struct AdvanceBlock *handle);

struct Adxr *wickra_adxr_new(uintptr_t period);

double wickra_adxr_update(struct Adxr *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp);

void wickra_adxr_batch(struct Adxr *handle,
                       const double *open,
                       const double *high,
                       const double *low,
                       const double *close,
                       const double *volume,
                       const int64_t *timestamp,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_adxr_warmup_period(struct Adxr *handle);

bool wickra_adxr_is_ready(struct Adxr *handle);

const char *wickra_adxr_name(struct Adxr *handle);

void wickra_adxr_reset(struct Adxr *handle);

void wickra_adxr_free(struct Adxr *handle);

struct AnchoredVwap *wickra_anchored_vwap_new(void);

double wickra_anchored_vwap_update(struct AnchoredVwap *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_anchored_vwap_batch(struct AnchoredVwap *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_anchored_vwap_warmup_period(struct AnchoredVwap *handle);

bool wickra_anchored_vwap_is_ready(struct AnchoredVwap *handle);

const char *wickra_anchored_vwap_name(struct AnchoredVwap *handle);

void wickra_anchored_vwap_reset(struct AnchoredVwap *handle);

void wickra_anchored_vwap_free(struct AnchoredVwap *handle);

struct AroonOscillator *wickra_aroon_oscillator_new(uintptr_t period);

double wickra_aroon_oscillator_update(struct AroonOscillator *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_aroon_oscillator_batch(struct AroonOscillator *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_aroon_oscillator_warmup_period(struct AroonOscillator *handle);

bool wickra_aroon_oscillator_is_ready(struct AroonOscillator *handle);

const char *wickra_aroon_oscillator_name(struct AroonOscillator *handle);

void wickra_aroon_oscillator_reset(struct AroonOscillator *handle);

void wickra_aroon_oscillator_free(struct AroonOscillator *handle);

struct Atr *wickra_atr_new(uintptr_t period);

double wickra_atr_update(struct Atr *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_atr_batch(struct Atr *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_atr_warmup_period(struct Atr *handle);

bool wickra_atr_is_ready(struct Atr *handle);

const char *wickra_atr_name(struct Atr *handle);

void wickra_atr_reset(struct Atr *handle);

void wickra_atr_free(struct Atr *handle);

struct AtrTrailingStop *wickra_atr_trailing_stop_new(uintptr_t atr_period, double multiplier);

double wickra_atr_trailing_stop_update(struct AtrTrailingStop *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_atr_trailing_stop_batch(struct AtrTrailingStop *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_atr_trailing_stop_warmup_period(struct AtrTrailingStop *handle);

bool wickra_atr_trailing_stop_is_ready(struct AtrTrailingStop *handle);

const char *wickra_atr_trailing_stop_name(struct AtrTrailingStop *handle);

void wickra_atr_trailing_stop_reset(struct AtrTrailingStop *handle);

void wickra_atr_trailing_stop_free(struct AtrTrailingStop *handle);

struct AverageDailyRange *wickra_average_daily_range_new(uintptr_t period,
                                                         int32_t utc_offset_minutes);

double wickra_average_daily_range_update(struct AverageDailyRange *handle,
                                         double open,
                                         double high,
                                         double low,
                                         double close,
                                         double volume,
                                         int64_t timestamp);

void wickra_average_daily_range_batch(struct AverageDailyRange *handle,
                                      const double *open,
                                      const double *high,
                                      const double *low,
                                      const double *close,
                                      const double *volume,
                                      const int64_t *timestamp,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_average_daily_range_warmup_period(struct AverageDailyRange *handle);

bool wickra_average_daily_range_is_ready(struct AverageDailyRange *handle);

const char *wickra_average_daily_range_name(struct AverageDailyRange *handle);

void wickra_average_daily_range_reset(struct AverageDailyRange *handle);

void wickra_average_daily_range_free(struct AverageDailyRange *handle);

struct AvgPrice *wickra_avg_price_new(void);

double wickra_avg_price_update(struct AvgPrice *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_avg_price_batch(struct AvgPrice *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_avg_price_warmup_period(struct AvgPrice *handle);

bool wickra_avg_price_is_ready(struct AvgPrice *handle);

const char *wickra_avg_price_name(struct AvgPrice *handle);

void wickra_avg_price_reset(struct AvgPrice *handle);

void wickra_avg_price_free(struct AvgPrice *handle);

struct AwesomeOscillator *wickra_awesome_oscillator_new(uintptr_t fast, uintptr_t slow);

double wickra_awesome_oscillator_update(struct AwesomeOscillator *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_awesome_oscillator_batch(struct AwesomeOscillator *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_awesome_oscillator_warmup_period(struct AwesomeOscillator *handle);

bool wickra_awesome_oscillator_is_ready(struct AwesomeOscillator *handle);

const char *wickra_awesome_oscillator_name(struct AwesomeOscillator *handle);

void wickra_awesome_oscillator_reset(struct AwesomeOscillator *handle);

void wickra_awesome_oscillator_free(struct AwesomeOscillator *handle);

struct AwesomeOscillatorHistogram *wickra_awesome_oscillator_histogram_new(uintptr_t fast,
                                                                           uintptr_t slow,
                                                                           uintptr_t lookback);

double wickra_awesome_oscillator_histogram_update(struct AwesomeOscillatorHistogram *handle,
                                                  double open,
                                                  double high,
                                                  double low,
                                                  double close,
                                                  double volume,
                                                  int64_t timestamp);

void wickra_awesome_oscillator_histogram_batch(struct AwesomeOscillatorHistogram *handle,
                                               const double *open,
                                               const double *high,
                                               const double *low,
                                               const double *close,
                                               const double *volume,
                                               const int64_t *timestamp,
                                               double *out,
                                               uintptr_t n);

uintptr_t wickra_awesome_oscillator_histogram_warmup_period(struct AwesomeOscillatorHistogram *handle);

bool wickra_awesome_oscillator_histogram_is_ready(struct AwesomeOscillatorHistogram *handle);

const char *wickra_awesome_oscillator_histogram_name(struct AwesomeOscillatorHistogram *handle);

void wickra_awesome_oscillator_histogram_reset(struct AwesomeOscillatorHistogram *handle);

void wickra_awesome_oscillator_histogram_free(struct AwesomeOscillatorHistogram *handle);

struct BalanceOfPower *wickra_balance_of_power_new(void);

double wickra_balance_of_power_update(struct BalanceOfPower *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_balance_of_power_batch(struct BalanceOfPower *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_balance_of_power_warmup_period(struct BalanceOfPower *handle);

bool wickra_balance_of_power_is_ready(struct BalanceOfPower *handle);

const char *wickra_balance_of_power_name(struct BalanceOfPower *handle);

void wickra_balance_of_power_reset(struct BalanceOfPower *handle);

void wickra_balance_of_power_free(struct BalanceOfPower *handle);

struct Bat *wickra_bat_new(void);

double wickra_bat_update(struct Bat *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_bat_batch(struct Bat *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_bat_warmup_period(struct Bat *handle);

bool wickra_bat_is_ready(struct Bat *handle);

const char *wickra_bat_name(struct Bat *handle);

void wickra_bat_reset(struct Bat *handle);

void wickra_bat_free(struct Bat *handle);

struct BeltHold *wickra_belt_hold_new(void);

double wickra_belt_hold_update(struct BeltHold *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_belt_hold_batch(struct BeltHold *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_belt_hold_warmup_period(struct BeltHold *handle);

bool wickra_belt_hold_is_ready(struct BeltHold *handle);

const char *wickra_belt_hold_name(struct BeltHold *handle);

void wickra_belt_hold_reset(struct BeltHold *handle);

void wickra_belt_hold_free(struct BeltHold *handle);

struct BetterVolume *wickra_better_volume_new(uintptr_t period);

double wickra_better_volume_update(struct BetterVolume *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_better_volume_batch(struct BetterVolume *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_better_volume_warmup_period(struct BetterVolume *handle);

bool wickra_better_volume_is_ready(struct BetterVolume *handle);

const char *wickra_better_volume_name(struct BetterVolume *handle);

void wickra_better_volume_reset(struct BetterVolume *handle);

void wickra_better_volume_free(struct BetterVolume *handle);

struct BodySizePct *wickra_body_size_pct_new(void);

double wickra_body_size_pct_update(struct BodySizePct *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_body_size_pct_batch(struct BodySizePct *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_body_size_pct_warmup_period(struct BodySizePct *handle);

bool wickra_body_size_pct_is_ready(struct BodySizePct *handle);

const char *wickra_body_size_pct_name(struct BodySizePct *handle);

void wickra_body_size_pct_reset(struct BodySizePct *handle);

void wickra_body_size_pct_free(struct BodySizePct *handle);

struct Breakaway *wickra_breakaway_new(void);

double wickra_breakaway_update(struct Breakaway *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_breakaway_batch(struct Breakaway *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_breakaway_warmup_period(struct Breakaway *handle);

bool wickra_breakaway_is_ready(struct Breakaway *handle);

const char *wickra_breakaway_name(struct Breakaway *handle);

void wickra_breakaway_reset(struct Breakaway *handle);

void wickra_breakaway_free(struct Breakaway *handle);

struct Butterfly *wickra_butterfly_new(void);

double wickra_butterfly_update(struct Butterfly *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_butterfly_batch(struct Butterfly *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_butterfly_warmup_period(struct Butterfly *handle);

bool wickra_butterfly_is_ready(struct Butterfly *handle);

const char *wickra_butterfly_name(struct Butterfly *handle);

void wickra_butterfly_reset(struct Butterfly *handle);

void wickra_butterfly_free(struct Butterfly *handle);

struct Cci *wickra_cci_new(uintptr_t period);

double wickra_cci_update(struct Cci *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_cci_batch(struct Cci *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_cci_warmup_period(struct Cci *handle);

bool wickra_cci_is_ready(struct Cci *handle);

const char *wickra_cci_name(struct Cci *handle);

void wickra_cci_reset(struct Cci *handle);

void wickra_cci_free(struct Cci *handle);

struct ChaikinOscillator *wickra_chaikin_oscillator_new(uintptr_t fast, uintptr_t slow);

double wickra_chaikin_oscillator_update(struct ChaikinOscillator *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_chaikin_oscillator_batch(struct ChaikinOscillator *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_chaikin_oscillator_warmup_period(struct ChaikinOscillator *handle);

bool wickra_chaikin_oscillator_is_ready(struct ChaikinOscillator *handle);

const char *wickra_chaikin_oscillator_name(struct ChaikinOscillator *handle);

void wickra_chaikin_oscillator_reset(struct ChaikinOscillator *handle);

void wickra_chaikin_oscillator_free(struct ChaikinOscillator *handle);

struct ChaikinVolatility *wickra_chaikin_volatility_new(uintptr_t ema_period, uintptr_t roc_period);

double wickra_chaikin_volatility_update(struct ChaikinVolatility *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_chaikin_volatility_batch(struct ChaikinVolatility *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_chaikin_volatility_warmup_period(struct ChaikinVolatility *handle);

bool wickra_chaikin_volatility_is_ready(struct ChaikinVolatility *handle);

const char *wickra_chaikin_volatility_name(struct ChaikinVolatility *handle);

void wickra_chaikin_volatility_reset(struct ChaikinVolatility *handle);

void wickra_chaikin_volatility_free(struct ChaikinVolatility *handle);

struct ChoppinessIndex *wickra_choppiness_index_new(uintptr_t period);

double wickra_choppiness_index_update(struct ChoppinessIndex *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_choppiness_index_batch(struct ChoppinessIndex *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_choppiness_index_warmup_period(struct ChoppinessIndex *handle);

bool wickra_choppiness_index_is_ready(struct ChoppinessIndex *handle);

const char *wickra_choppiness_index_name(struct ChoppinessIndex *handle);

void wickra_choppiness_index_reset(struct ChoppinessIndex *handle);

void wickra_choppiness_index_free(struct ChoppinessIndex *handle);

struct CloseVsOpen *wickra_close_vs_open_new(void);

double wickra_close_vs_open_update(struct CloseVsOpen *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_close_vs_open_batch(struct CloseVsOpen *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_close_vs_open_warmup_period(struct CloseVsOpen *handle);

bool wickra_close_vs_open_is_ready(struct CloseVsOpen *handle);

const char *wickra_close_vs_open_name(struct CloseVsOpen *handle);

void wickra_close_vs_open_reset(struct CloseVsOpen *handle);

void wickra_close_vs_open_free(struct CloseVsOpen *handle);

struct ClosingMarubozu *wickra_closing_marubozu_new(void);

double wickra_closing_marubozu_update(struct ClosingMarubozu *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_closing_marubozu_batch(struct ClosingMarubozu *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_closing_marubozu_warmup_period(struct ClosingMarubozu *handle);

bool wickra_closing_marubozu_is_ready(struct ClosingMarubozu *handle);

const char *wickra_closing_marubozu_name(struct ClosingMarubozu *handle);

void wickra_closing_marubozu_reset(struct ClosingMarubozu *handle);

void wickra_closing_marubozu_free(struct ClosingMarubozu *handle);

struct ChaikinMoneyFlow *wickra_chaikin_money_flow_new(uintptr_t period);

double wickra_chaikin_money_flow_update(struct ChaikinMoneyFlow *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_chaikin_money_flow_batch(struct ChaikinMoneyFlow *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_chaikin_money_flow_warmup_period(struct ChaikinMoneyFlow *handle);

bool wickra_chaikin_money_flow_is_ready(struct ChaikinMoneyFlow *handle);

const char *wickra_chaikin_money_flow_name(struct ChaikinMoneyFlow *handle);

void wickra_chaikin_money_flow_reset(struct ChaikinMoneyFlow *handle);

void wickra_chaikin_money_flow_free(struct ChaikinMoneyFlow *handle);

struct ConcealingBabySwallow *wickra_concealing_baby_swallow_new(void);

double wickra_concealing_baby_swallow_update(struct ConcealingBabySwallow *handle,
                                             double open,
                                             double high,
                                             double low,
                                             double close,
                                             double volume,
                                             int64_t timestamp);

void wickra_concealing_baby_swallow_batch(struct ConcealingBabySwallow *handle,
                                          const double *open,
                                          const double *high,
                                          const double *low,
                                          const double *close,
                                          const double *volume,
                                          const int64_t *timestamp,
                                          double *out,
                                          uintptr_t n);

uintptr_t wickra_concealing_baby_swallow_warmup_period(struct ConcealingBabySwallow *handle);

bool wickra_concealing_baby_swallow_is_ready(struct ConcealingBabySwallow *handle);

const char *wickra_concealing_baby_swallow_name(struct ConcealingBabySwallow *handle);

void wickra_concealing_baby_swallow_reset(struct ConcealingBabySwallow *handle);

void wickra_concealing_baby_swallow_free(struct ConcealingBabySwallow *handle);

struct Counterattack *wickra_counterattack_new(void);

double wickra_counterattack_update(struct Counterattack *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_counterattack_batch(struct Counterattack *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_counterattack_warmup_period(struct Counterattack *handle);

bool wickra_counterattack_is_ready(struct Counterattack *handle);

const char *wickra_counterattack_name(struct Counterattack *handle);

void wickra_counterattack_reset(struct Counterattack *handle);

void wickra_counterattack_free(struct Counterattack *handle);

struct Crab *wickra_crab_new(void);

double wickra_crab_update(struct Crab *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp);

void wickra_crab_batch(struct Crab *handle,
                       const double *open,
                       const double *high,
                       const double *low,
                       const double *close,
                       const double *volume,
                       const int64_t *timestamp,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_crab_warmup_period(struct Crab *handle);

bool wickra_crab_is_ready(struct Crab *handle);

const char *wickra_crab_name(struct Crab *handle);

void wickra_crab_reset(struct Crab *handle);

void wickra_crab_free(struct Crab *handle);

struct CupAndHandle *wickra_cup_and_handle_new(void);

double wickra_cup_and_handle_update(struct CupAndHandle *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_cup_and_handle_batch(struct CupAndHandle *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_cup_and_handle_warmup_period(struct CupAndHandle *handle);

bool wickra_cup_and_handle_is_ready(struct CupAndHandle *handle);

const char *wickra_cup_and_handle_name(struct CupAndHandle *handle);

void wickra_cup_and_handle_reset(struct CupAndHandle *handle);

void wickra_cup_and_handle_free(struct CupAndHandle *handle);

struct Cypher *wickra_cypher_new(void);

double wickra_cypher_update(struct Cypher *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp);

void wickra_cypher_batch(struct Cypher *handle,
                         const double *open,
                         const double *high,
                         const double *low,
                         const double *close,
                         const double *volume,
                         const int64_t *timestamp,
                         double *out,
                         uintptr_t n);

uintptr_t wickra_cypher_warmup_period(struct Cypher *handle);

bool wickra_cypher_is_ready(struct Cypher *handle);

const char *wickra_cypher_name(struct Cypher *handle);

void wickra_cypher_reset(struct Cypher *handle);

void wickra_cypher_free(struct Cypher *handle);

struct DemandIndex *wickra_demand_index_new(uintptr_t period);

double wickra_demand_index_update(struct DemandIndex *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_demand_index_batch(struct DemandIndex *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_demand_index_warmup_period(struct DemandIndex *handle);

bool wickra_demand_index_is_ready(struct DemandIndex *handle);

const char *wickra_demand_index_name(struct DemandIndex *handle);

void wickra_demand_index_reset(struct DemandIndex *handle);

void wickra_demand_index_free(struct DemandIndex *handle);

struct Doji *wickra_doji_new(void);

double wickra_doji_update(struct Doji *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp);

void wickra_doji_batch(struct Doji *handle,
                       const double *open,
                       const double *high,
                       const double *low,
                       const double *close,
                       const double *volume,
                       const int64_t *timestamp,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_doji_warmup_period(struct Doji *handle);

bool wickra_doji_is_ready(struct Doji *handle);

const char *wickra_doji_name(struct Doji *handle);

void wickra_doji_reset(struct Doji *handle);

void wickra_doji_free(struct Doji *handle);

struct DojiStar *wickra_doji_star_new(void);

double wickra_doji_star_update(struct DojiStar *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_doji_star_batch(struct DojiStar *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_doji_star_warmup_period(struct DojiStar *handle);

bool wickra_doji_star_is_ready(struct DojiStar *handle);

const char *wickra_doji_star_name(struct DojiStar *handle);

void wickra_doji_star_reset(struct DojiStar *handle);

void wickra_doji_star_free(struct DojiStar *handle);

struct DoubleTopBottom *wickra_double_top_bottom_new(void);

double wickra_double_top_bottom_update(struct DoubleTopBottom *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_double_top_bottom_batch(struct DoubleTopBottom *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_double_top_bottom_warmup_period(struct DoubleTopBottom *handle);

bool wickra_double_top_bottom_is_ready(struct DoubleTopBottom *handle);

const char *wickra_double_top_bottom_name(struct DoubleTopBottom *handle);

void wickra_double_top_bottom_reset(struct DoubleTopBottom *handle);

void wickra_double_top_bottom_free(struct DoubleTopBottom *handle);

struct DownsideGapThreeMethods *wickra_downside_gap_three_methods_new(void);

double wickra_downside_gap_three_methods_update(struct DownsideGapThreeMethods *handle,
                                                double open,
                                                double high,
                                                double low,
                                                double close,
                                                double volume,
                                                int64_t timestamp);

void wickra_downside_gap_three_methods_batch(struct DownsideGapThreeMethods *handle,
                                             const double *open,
                                             const double *high,
                                             const double *low,
                                             const double *close,
                                             const double *volume,
                                             const int64_t *timestamp,
                                             double *out,
                                             uintptr_t n);

uintptr_t wickra_downside_gap_three_methods_warmup_period(struct DownsideGapThreeMethods *handle);

bool wickra_downside_gap_three_methods_is_ready(struct DownsideGapThreeMethods *handle);

const char *wickra_downside_gap_three_methods_name(struct DownsideGapThreeMethods *handle);

void wickra_downside_gap_three_methods_reset(struct DownsideGapThreeMethods *handle);

void wickra_downside_gap_three_methods_free(struct DownsideGapThreeMethods *handle);

struct DragonflyDoji *wickra_dragonfly_doji_new(void);

double wickra_dragonfly_doji_update(struct DragonflyDoji *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_dragonfly_doji_batch(struct DragonflyDoji *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_dragonfly_doji_warmup_period(struct DragonflyDoji *handle);

bool wickra_dragonfly_doji_is_ready(struct DragonflyDoji *handle);

const char *wickra_dragonfly_doji_name(struct DragonflyDoji *handle);

void wickra_dragonfly_doji_reset(struct DragonflyDoji *handle);

void wickra_dragonfly_doji_free(struct DragonflyDoji *handle);

struct DumplingTop *wickra_dumpling_top_new(uintptr_t period);

double wickra_dumpling_top_update(struct DumplingTop *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_dumpling_top_batch(struct DumplingTop *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_dumpling_top_warmup_period(struct DumplingTop *handle);

bool wickra_dumpling_top_is_ready(struct DumplingTop *handle);

const char *wickra_dumpling_top_name(struct DumplingTop *handle);

void wickra_dumpling_top_reset(struct DumplingTop *handle);

void wickra_dumpling_top_free(struct DumplingTop *handle);

struct Dx *wickra_dx_new(uintptr_t period);

double wickra_dx_update(struct Dx *handle,
                        double open,
                        double high,
                        double low,
                        double close,
                        double volume,
                        int64_t timestamp);

void wickra_dx_batch(struct Dx *handle,
                     const double *open,
                     const double *high,
                     const double *low,
                     const double *close,
                     const double *volume,
                     const int64_t *timestamp,
                     double *out,
                     uintptr_t n);

uintptr_t wickra_dx_warmup_period(struct Dx *handle);

bool wickra_dx_is_ready(struct Dx *handle);

const char *wickra_dx_name(struct Dx *handle);

void wickra_dx_reset(struct Dx *handle);

void wickra_dx_free(struct Dx *handle);

struct EaseOfMovement *wickra_ease_of_movement_new(uintptr_t period);

double wickra_ease_of_movement_update(struct EaseOfMovement *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_ease_of_movement_batch(struct EaseOfMovement *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_ease_of_movement_warmup_period(struct EaseOfMovement *handle);

bool wickra_ease_of_movement_is_ready(struct EaseOfMovement *handle);

const char *wickra_ease_of_movement_name(struct EaseOfMovement *handle);

void wickra_ease_of_movement_reset(struct EaseOfMovement *handle);

void wickra_ease_of_movement_free(struct EaseOfMovement *handle);

struct Engulfing *wickra_engulfing_new(void);

double wickra_engulfing_update(struct Engulfing *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_engulfing_batch(struct Engulfing *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_engulfing_warmup_period(struct Engulfing *handle);

bool wickra_engulfing_is_ready(struct Engulfing *handle);

const char *wickra_engulfing_name(struct Engulfing *handle);

void wickra_engulfing_reset(struct Engulfing *handle);

void wickra_engulfing_free(struct Engulfing *handle);

struct EveningDojiStar *wickra_evening_doji_star_new(void);

double wickra_evening_doji_star_update(struct EveningDojiStar *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_evening_doji_star_batch(struct EveningDojiStar *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_evening_doji_star_warmup_period(struct EveningDojiStar *handle);

bool wickra_evening_doji_star_is_ready(struct EveningDojiStar *handle);

const char *wickra_evening_doji_star_name(struct EveningDojiStar *handle);

void wickra_evening_doji_star_reset(struct EveningDojiStar *handle);

void wickra_evening_doji_star_free(struct EveningDojiStar *handle);

struct Evwma *wickra_evwma_new(uintptr_t period);

double wickra_evwma_update(struct Evwma *handle,
                           double open,
                           double high,
                           double low,
                           double close,
                           double volume,
                           int64_t timestamp);

void wickra_evwma_batch(struct Evwma *handle,
                        const double *open,
                        const double *high,
                        const double *low,
                        const double *close,
                        const double *volume,
                        const int64_t *timestamp,
                        double *out,
                        uintptr_t n);

uintptr_t wickra_evwma_warmup_period(struct Evwma *handle);

bool wickra_evwma_is_ready(struct Evwma *handle);

const char *wickra_evwma_name(struct Evwma *handle);

void wickra_evwma_reset(struct Evwma *handle);

void wickra_evwma_free(struct Evwma *handle);

struct FallingThreeMethods *wickra_falling_three_methods_new(void);

double wickra_falling_three_methods_update(struct FallingThreeMethods *handle,
                                           double open,
                                           double high,
                                           double low,
                                           double close,
                                           double volume,
                                           int64_t timestamp);

void wickra_falling_three_methods_batch(struct FallingThreeMethods *handle,
                                        const double *open,
                                        const double *high,
                                        const double *low,
                                        const double *close,
                                        const double *volume,
                                        const int64_t *timestamp,
                                        double *out,
                                        uintptr_t n);

uintptr_t wickra_falling_three_methods_warmup_period(struct FallingThreeMethods *handle);

bool wickra_falling_three_methods_is_ready(struct FallingThreeMethods *handle);

const char *wickra_falling_three_methods_name(struct FallingThreeMethods *handle);

void wickra_falling_three_methods_reset(struct FallingThreeMethods *handle);

void wickra_falling_three_methods_free(struct FallingThreeMethods *handle);

struct FlagPennant *wickra_flag_pennant_new(void);

double wickra_flag_pennant_update(struct FlagPennant *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_flag_pennant_batch(struct FlagPennant *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_flag_pennant_warmup_period(struct FlagPennant *handle);

bool wickra_flag_pennant_is_ready(struct FlagPennant *handle);

const char *wickra_flag_pennant_name(struct FlagPennant *handle);

void wickra_flag_pennant_reset(struct FlagPennant *handle);

void wickra_flag_pennant_free(struct FlagPennant *handle);

struct ForceIndex *wickra_force_index_new(uintptr_t period);

double wickra_force_index_update(struct ForceIndex *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp);

void wickra_force_index_batch(struct ForceIndex *handle,
                              const double *open,
                              const double *high,
                              const double *low,
                              const double *close,
                              const double *volume,
                              const int64_t *timestamp,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_force_index_warmup_period(struct ForceIndex *handle);

bool wickra_force_index_is_ready(struct ForceIndex *handle);

const char *wickra_force_index_name(struct ForceIndex *handle);

void wickra_force_index_reset(struct ForceIndex *handle);

void wickra_force_index_free(struct ForceIndex *handle);

struct FryPanBottom *wickra_fry_pan_bottom_new(uintptr_t period);

double wickra_fry_pan_bottom_update(struct FryPanBottom *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_fry_pan_bottom_batch(struct FryPanBottom *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_fry_pan_bottom_warmup_period(struct FryPanBottom *handle);

bool wickra_fry_pan_bottom_is_ready(struct FryPanBottom *handle);

const char *wickra_fry_pan_bottom_name(struct FryPanBottom *handle);

void wickra_fry_pan_bottom_reset(struct FryPanBottom *handle);

void wickra_fry_pan_bottom_free(struct FryPanBottom *handle);

struct GapSideBySideWhite *wickra_gap_side_by_side_white_new(void);

double wickra_gap_side_by_side_white_update(struct GapSideBySideWhite *handle,
                                            double open,
                                            double high,
                                            double low,
                                            double close,
                                            double volume,
                                            int64_t timestamp);

void wickra_gap_side_by_side_white_batch(struct GapSideBySideWhite *handle,
                                         const double *open,
                                         const double *high,
                                         const double *low,
                                         const double *close,
                                         const double *volume,
                                         const int64_t *timestamp,
                                         double *out,
                                         uintptr_t n);

uintptr_t wickra_gap_side_by_side_white_warmup_period(struct GapSideBySideWhite *handle);

bool wickra_gap_side_by_side_white_is_ready(struct GapSideBySideWhite *handle);

const char *wickra_gap_side_by_side_white_name(struct GapSideBySideWhite *handle);

void wickra_gap_side_by_side_white_reset(struct GapSideBySideWhite *handle);

void wickra_gap_side_by_side_white_free(struct GapSideBySideWhite *handle);

struct GarmanKlassVolatility *wickra_garman_klass_volatility_new(uintptr_t period,
                                                                 uintptr_t trading_periods);

double wickra_garman_klass_volatility_update(struct GarmanKlassVolatility *handle,
                                             double open,
                                             double high,
                                             double low,
                                             double close,
                                             double volume,
                                             int64_t timestamp);

void wickra_garman_klass_volatility_batch(struct GarmanKlassVolatility *handle,
                                          const double *open,
                                          const double *high,
                                          const double *low,
                                          const double *close,
                                          const double *volume,
                                          const int64_t *timestamp,
                                          double *out,
                                          uintptr_t n);

uintptr_t wickra_garman_klass_volatility_warmup_period(struct GarmanKlassVolatility *handle);

bool wickra_garman_klass_volatility_is_ready(struct GarmanKlassVolatility *handle);

const char *wickra_garman_klass_volatility_name(struct GarmanKlassVolatility *handle);

void wickra_garman_klass_volatility_reset(struct GarmanKlassVolatility *handle);

void wickra_garman_klass_volatility_free(struct GarmanKlassVolatility *handle);

struct Gartley *wickra_gartley_new(void);

double wickra_gartley_update(struct Gartley *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_gartley_batch(struct Gartley *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_gartley_warmup_period(struct Gartley *handle);

bool wickra_gartley_is_ready(struct Gartley *handle);

const char *wickra_gartley_name(struct Gartley *handle);

void wickra_gartley_reset(struct Gartley *handle);

void wickra_gartley_free(struct Gartley *handle);

struct GravestoneDoji *wickra_gravestone_doji_new(void);

double wickra_gravestone_doji_update(struct GravestoneDoji *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp);

void wickra_gravestone_doji_batch(struct GravestoneDoji *handle,
                                  const double *open,
                                  const double *high,
                                  const double *low,
                                  const double *close,
                                  const double *volume,
                                  const int64_t *timestamp,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_gravestone_doji_warmup_period(struct GravestoneDoji *handle);

bool wickra_gravestone_doji_is_ready(struct GravestoneDoji *handle);

const char *wickra_gravestone_doji_name(struct GravestoneDoji *handle);

void wickra_gravestone_doji_reset(struct GravestoneDoji *handle);

void wickra_gravestone_doji_free(struct GravestoneDoji *handle);

struct Hammer *wickra_hammer_new(void);

double wickra_hammer_update(struct Hammer *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp);

void wickra_hammer_batch(struct Hammer *handle,
                         const double *open,
                         const double *high,
                         const double *low,
                         const double *close,
                         const double *volume,
                         const int64_t *timestamp,
                         double *out,
                         uintptr_t n);

uintptr_t wickra_hammer_warmup_period(struct Hammer *handle);

bool wickra_hammer_is_ready(struct Hammer *handle);

const char *wickra_hammer_name(struct Hammer *handle);

void wickra_hammer_reset(struct Hammer *handle);

void wickra_hammer_free(struct Hammer *handle);

struct HangingMan *wickra_hanging_man_new(void);

double wickra_hanging_man_update(struct HangingMan *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp);

void wickra_hanging_man_batch(struct HangingMan *handle,
                              const double *open,
                              const double *high,
                              const double *low,
                              const double *close,
                              const double *volume,
                              const int64_t *timestamp,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_hanging_man_warmup_period(struct HangingMan *handle);

bool wickra_hanging_man_is_ready(struct HangingMan *handle);

const char *wickra_hanging_man_name(struct HangingMan *handle);

void wickra_hanging_man_reset(struct HangingMan *handle);

void wickra_hanging_man_free(struct HangingMan *handle);

struct Harami *wickra_harami_new(void);

double wickra_harami_update(struct Harami *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp);

void wickra_harami_batch(struct Harami *handle,
                         const double *open,
                         const double *high,
                         const double *low,
                         const double *close,
                         const double *volume,
                         const int64_t *timestamp,
                         double *out,
                         uintptr_t n);

uintptr_t wickra_harami_warmup_period(struct Harami *handle);

bool wickra_harami_is_ready(struct Harami *handle);

const char *wickra_harami_name(struct Harami *handle);

void wickra_harami_reset(struct Harami *handle);

void wickra_harami_free(struct Harami *handle);

struct HaramiCross *wickra_harami_cross_new(void);

double wickra_harami_cross_update(struct HaramiCross *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_harami_cross_batch(struct HaramiCross *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_harami_cross_warmup_period(struct HaramiCross *handle);

bool wickra_harami_cross_is_ready(struct HaramiCross *handle);

const char *wickra_harami_cross_name(struct HaramiCross *handle);

void wickra_harami_cross_reset(struct HaramiCross *handle);

void wickra_harami_cross_free(struct HaramiCross *handle);

struct HeadAndShoulders *wickra_head_and_shoulders_new(void);

double wickra_head_and_shoulders_update(struct HeadAndShoulders *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_head_and_shoulders_batch(struct HeadAndShoulders *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_head_and_shoulders_warmup_period(struct HeadAndShoulders *handle);

bool wickra_head_and_shoulders_is_ready(struct HeadAndShoulders *handle);

const char *wickra_head_and_shoulders_name(struct HeadAndShoulders *handle);

void wickra_head_and_shoulders_reset(struct HeadAndShoulders *handle);

void wickra_head_and_shoulders_free(struct HeadAndShoulders *handle);

struct HeikinAshiOscillator *wickra_heikin_ashi_oscillator_new(uintptr_t period);

double wickra_heikin_ashi_oscillator_update(struct HeikinAshiOscillator *handle,
                                            double open,
                                            double high,
                                            double low,
                                            double close,
                                            double volume,
                                            int64_t timestamp);

void wickra_heikin_ashi_oscillator_batch(struct HeikinAshiOscillator *handle,
                                         const double *open,
                                         const double *high,
                                         const double *low,
                                         const double *close,
                                         const double *volume,
                                         const int64_t *timestamp,
                                         double *out,
                                         uintptr_t n);

uintptr_t wickra_heikin_ashi_oscillator_warmup_period(struct HeikinAshiOscillator *handle);

bool wickra_heikin_ashi_oscillator_is_ready(struct HeikinAshiOscillator *handle);

const char *wickra_heikin_ashi_oscillator_name(struct HeikinAshiOscillator *handle);

void wickra_heikin_ashi_oscillator_reset(struct HeikinAshiOscillator *handle);

void wickra_heikin_ashi_oscillator_free(struct HeikinAshiOscillator *handle);

struct HighLowRange *wickra_high_low_range_new(void);

double wickra_high_low_range_update(struct HighLowRange *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_high_low_range_batch(struct HighLowRange *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_high_low_range_warmup_period(struct HighLowRange *handle);

bool wickra_high_low_range_is_ready(struct HighLowRange *handle);

const char *wickra_high_low_range_name(struct HighLowRange *handle);

void wickra_high_low_range_reset(struct HighLowRange *handle);

void wickra_high_low_range_free(struct HighLowRange *handle);

struct HighWave *wickra_high_wave_new(void);

double wickra_high_wave_update(struct HighWave *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_high_wave_batch(struct HighWave *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_high_wave_warmup_period(struct HighWave *handle);

bool wickra_high_wave_is_ready(struct HighWave *handle);

const char *wickra_high_wave_name(struct HighWave *handle);

void wickra_high_wave_reset(struct HighWave *handle);

void wickra_high_wave_free(struct HighWave *handle);

struct Hikkake *wickra_hikkake_new(void);

double wickra_hikkake_update(struct Hikkake *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_hikkake_batch(struct Hikkake *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_hikkake_warmup_period(struct Hikkake *handle);

bool wickra_hikkake_is_ready(struct Hikkake *handle);

const char *wickra_hikkake_name(struct Hikkake *handle);

void wickra_hikkake_reset(struct Hikkake *handle);

void wickra_hikkake_free(struct Hikkake *handle);

struct HikkakeModified *wickra_hikkake_modified_new(void);

double wickra_hikkake_modified_update(struct HikkakeModified *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_hikkake_modified_batch(struct HikkakeModified *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_hikkake_modified_warmup_period(struct HikkakeModified *handle);

bool wickra_hikkake_modified_is_ready(struct HikkakeModified *handle);

const char *wickra_hikkake_modified_name(struct HikkakeModified *handle);

void wickra_hikkake_modified_reset(struct HikkakeModified *handle);

void wickra_hikkake_modified_free(struct HikkakeModified *handle);

struct HiLoActivator *wickra_hi_lo_activator_new(uintptr_t period);

double wickra_hi_lo_activator_update(struct HiLoActivator *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp);

void wickra_hi_lo_activator_batch(struct HiLoActivator *handle,
                                  const double *open,
                                  const double *high,
                                  const double *low,
                                  const double *close,
                                  const double *volume,
                                  const int64_t *timestamp,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_hi_lo_activator_warmup_period(struct HiLoActivator *handle);

bool wickra_hi_lo_activator_is_ready(struct HiLoActivator *handle);

const char *wickra_hi_lo_activator_name(struct HiLoActivator *handle);

void wickra_hi_lo_activator_reset(struct HiLoActivator *handle);

void wickra_hi_lo_activator_free(struct HiLoActivator *handle);

struct HomingPigeon *wickra_homing_pigeon_new(void);

double wickra_homing_pigeon_update(struct HomingPigeon *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_homing_pigeon_batch(struct HomingPigeon *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_homing_pigeon_warmup_period(struct HomingPigeon *handle);

bool wickra_homing_pigeon_is_ready(struct HomingPigeon *handle);

const char *wickra_homing_pigeon_name(struct HomingPigeon *handle);

void wickra_homing_pigeon_reset(struct HomingPigeon *handle);

void wickra_homing_pigeon_free(struct HomingPigeon *handle);

struct IdenticalThreeCrows *wickra_identical_three_crows_new(void);

double wickra_identical_three_crows_update(struct IdenticalThreeCrows *handle,
                                           double open,
                                           double high,
                                           double low,
                                           double close,
                                           double volume,
                                           int64_t timestamp);

void wickra_identical_three_crows_batch(struct IdenticalThreeCrows *handle,
                                        const double *open,
                                        const double *high,
                                        const double *low,
                                        const double *close,
                                        const double *volume,
                                        const int64_t *timestamp,
                                        double *out,
                                        uintptr_t n);

uintptr_t wickra_identical_three_crows_warmup_period(struct IdenticalThreeCrows *handle);

bool wickra_identical_three_crows_is_ready(struct IdenticalThreeCrows *handle);

const char *wickra_identical_three_crows_name(struct IdenticalThreeCrows *handle);

void wickra_identical_three_crows_reset(struct IdenticalThreeCrows *handle);

void wickra_identical_three_crows_free(struct IdenticalThreeCrows *handle);

struct InNeck *wickra_in_neck_new(void);

double wickra_in_neck_update(struct InNeck *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_in_neck_batch(struct InNeck *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_in_neck_warmup_period(struct InNeck *handle);

bool wickra_in_neck_is_ready(struct InNeck *handle);

const char *wickra_in_neck_name(struct InNeck *handle);

void wickra_in_neck_reset(struct InNeck *handle);

void wickra_in_neck_free(struct InNeck *handle);

struct Inertia *wickra_inertia_new(uintptr_t rvi_period, uintptr_t linreg_period);

double wickra_inertia_update(struct Inertia *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_inertia_batch(struct Inertia *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_inertia_warmup_period(struct Inertia *handle);

bool wickra_inertia_is_ready(struct Inertia *handle);

const char *wickra_inertia_name(struct Inertia *handle);

void wickra_inertia_reset(struct Inertia *handle);

void wickra_inertia_free(struct Inertia *handle);

struct IntradayIntensity *wickra_intraday_intensity_new(void);

double wickra_intraday_intensity_update(struct IntradayIntensity *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_intraday_intensity_batch(struct IntradayIntensity *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_intraday_intensity_warmup_period(struct IntradayIntensity *handle);

bool wickra_intraday_intensity_is_ready(struct IntradayIntensity *handle);

const char *wickra_intraday_intensity_name(struct IntradayIntensity *handle);

void wickra_intraday_intensity_reset(struct IntradayIntensity *handle);

void wickra_intraday_intensity_free(struct IntradayIntensity *handle);

struct IntradayMomentumIndex *wickra_intraday_momentum_index_new(uintptr_t period);

double wickra_intraday_momentum_index_update(struct IntradayMomentumIndex *handle,
                                             double open,
                                             double high,
                                             double low,
                                             double close,
                                             double volume,
                                             int64_t timestamp);

void wickra_intraday_momentum_index_batch(struct IntradayMomentumIndex *handle,
                                          const double *open,
                                          const double *high,
                                          const double *low,
                                          const double *close,
                                          const double *volume,
                                          const int64_t *timestamp,
                                          double *out,
                                          uintptr_t n);

uintptr_t wickra_intraday_momentum_index_warmup_period(struct IntradayMomentumIndex *handle);

bool wickra_intraday_momentum_index_is_ready(struct IntradayMomentumIndex *handle);

const char *wickra_intraday_momentum_index_name(struct IntradayMomentumIndex *handle);

void wickra_intraday_momentum_index_reset(struct IntradayMomentumIndex *handle);

void wickra_intraday_momentum_index_free(struct IntradayMomentumIndex *handle);

struct InvertedHammer *wickra_inverted_hammer_new(void);

double wickra_inverted_hammer_update(struct InvertedHammer *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp);

void wickra_inverted_hammer_batch(struct InvertedHammer *handle,
                                  const double *open,
                                  const double *high,
                                  const double *low,
                                  const double *close,
                                  const double *volume,
                                  const int64_t *timestamp,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_inverted_hammer_warmup_period(struct InvertedHammer *handle);

bool wickra_inverted_hammer_is_ready(struct InvertedHammer *handle);

const char *wickra_inverted_hammer_name(struct InvertedHammer *handle);

void wickra_inverted_hammer_reset(struct InvertedHammer *handle);

void wickra_inverted_hammer_free(struct InvertedHammer *handle);

struct Kicking *wickra_kicking_new(void);

double wickra_kicking_update(struct Kicking *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_kicking_batch(struct Kicking *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_kicking_warmup_period(struct Kicking *handle);

bool wickra_kicking_is_ready(struct Kicking *handle);

const char *wickra_kicking_name(struct Kicking *handle);

void wickra_kicking_reset(struct Kicking *handle);

void wickra_kicking_free(struct Kicking *handle);

struct KickingByLength *wickra_kicking_by_length_new(void);

double wickra_kicking_by_length_update(struct KickingByLength *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_kicking_by_length_batch(struct KickingByLength *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_kicking_by_length_warmup_period(struct KickingByLength *handle);

bool wickra_kicking_by_length_is_ready(struct KickingByLength *handle);

const char *wickra_kicking_by_length_name(struct KickingByLength *handle);

void wickra_kicking_by_length_reset(struct KickingByLength *handle);

void wickra_kicking_by_length_free(struct KickingByLength *handle);

struct Kvo *wickra_kvo_new(uintptr_t fast, uintptr_t slow);

double wickra_kvo_update(struct Kvo *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_kvo_batch(struct Kvo *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_kvo_warmup_period(struct Kvo *handle);

bool wickra_kvo_is_ready(struct Kvo *handle);

const char *wickra_kvo_name(struct Kvo *handle);

void wickra_kvo_reset(struct Kvo *handle);

void wickra_kvo_free(struct Kvo *handle);

struct LadderBottom *wickra_ladder_bottom_new(void);

double wickra_ladder_bottom_update(struct LadderBottom *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_ladder_bottom_batch(struct LadderBottom *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_ladder_bottom_warmup_period(struct LadderBottom *handle);

bool wickra_ladder_bottom_is_ready(struct LadderBottom *handle);

const char *wickra_ladder_bottom_name(struct LadderBottom *handle);

void wickra_ladder_bottom_reset(struct LadderBottom *handle);

void wickra_ladder_bottom_free(struct LadderBottom *handle);

struct LongLeggedDoji *wickra_long_legged_doji_new(void);

double wickra_long_legged_doji_update(struct LongLeggedDoji *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_long_legged_doji_batch(struct LongLeggedDoji *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_long_legged_doji_warmup_period(struct LongLeggedDoji *handle);

bool wickra_long_legged_doji_is_ready(struct LongLeggedDoji *handle);

const char *wickra_long_legged_doji_name(struct LongLeggedDoji *handle);

void wickra_long_legged_doji_reset(struct LongLeggedDoji *handle);

void wickra_long_legged_doji_free(struct LongLeggedDoji *handle);

struct LongLine *wickra_long_line_new(void);

double wickra_long_line_update(struct LongLine *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_long_line_batch(struct LongLine *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_long_line_warmup_period(struct LongLine *handle);

bool wickra_long_line_is_ready(struct LongLine *handle);

const char *wickra_long_line_name(struct LongLine *handle);

void wickra_long_line_reset(struct LongLine *handle);

void wickra_long_line_free(struct LongLine *handle);

struct MarketFacilitationIndex *wickra_market_facilitation_index_new(void);

double wickra_market_facilitation_index_update(struct MarketFacilitationIndex *handle,
                                               double open,
                                               double high,
                                               double low,
                                               double close,
                                               double volume,
                                               int64_t timestamp);

void wickra_market_facilitation_index_batch(struct MarketFacilitationIndex *handle,
                                            const double *open,
                                            const double *high,
                                            const double *low,
                                            const double *close,
                                            const double *volume,
                                            const int64_t *timestamp,
                                            double *out,
                                            uintptr_t n);

uintptr_t wickra_market_facilitation_index_warmup_period(struct MarketFacilitationIndex *handle);

bool wickra_market_facilitation_index_is_ready(struct MarketFacilitationIndex *handle);

const char *wickra_market_facilitation_index_name(struct MarketFacilitationIndex *handle);

void wickra_market_facilitation_index_reset(struct MarketFacilitationIndex *handle);

void wickra_market_facilitation_index_free(struct MarketFacilitationIndex *handle);

struct Marubozu *wickra_marubozu_new(void);

double wickra_marubozu_update(struct Marubozu *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp);

void wickra_marubozu_batch(struct Marubozu *handle,
                           const double *open,
                           const double *high,
                           const double *low,
                           const double *close,
                           const double *volume,
                           const int64_t *timestamp,
                           double *out,
                           uintptr_t n);

uintptr_t wickra_marubozu_warmup_period(struct Marubozu *handle);

bool wickra_marubozu_is_ready(struct Marubozu *handle);

const char *wickra_marubozu_name(struct Marubozu *handle);

void wickra_marubozu_reset(struct Marubozu *handle);

void wickra_marubozu_free(struct Marubozu *handle);

struct MassIndex *wickra_mass_index_new(uintptr_t ema_period, uintptr_t sum_period);

double wickra_mass_index_update(struct MassIndex *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_mass_index_batch(struct MassIndex *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_mass_index_warmup_period(struct MassIndex *handle);

bool wickra_mass_index_is_ready(struct MassIndex *handle);

const char *wickra_mass_index_name(struct MassIndex *handle);

void wickra_mass_index_reset(struct MassIndex *handle);

void wickra_mass_index_free(struct MassIndex *handle);

struct MatHold *wickra_mat_hold_new(void);

double wickra_mat_hold_update(struct MatHold *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp);

void wickra_mat_hold_batch(struct MatHold *handle,
                           const double *open,
                           const double *high,
                           const double *low,
                           const double *close,
                           const double *volume,
                           const int64_t *timestamp,
                           double *out,
                           uintptr_t n);

uintptr_t wickra_mat_hold_warmup_period(struct MatHold *handle);

bool wickra_mat_hold_is_ready(struct MatHold *handle);

const char *wickra_mat_hold_name(struct MatHold *handle);

void wickra_mat_hold_reset(struct MatHold *handle);

void wickra_mat_hold_free(struct MatHold *handle);

struct MatchingLow *wickra_matching_low_new(void);

double wickra_matching_low_update(struct MatchingLow *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_matching_low_batch(struct MatchingLow *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_matching_low_warmup_period(struct MatchingLow *handle);

bool wickra_matching_low_is_ready(struct MatchingLow *handle);

const char *wickra_matching_low_name(struct MatchingLow *handle);

void wickra_matching_low_reset(struct MatchingLow *handle);

void wickra_matching_low_free(struct MatchingLow *handle);

struct MedianPrice *wickra_median_price_new(void);

double wickra_median_price_update(struct MedianPrice *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_median_price_batch(struct MedianPrice *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_median_price_warmup_period(struct MedianPrice *handle);

bool wickra_median_price_is_ready(struct MedianPrice *handle);

const char *wickra_median_price_name(struct MedianPrice *handle);

void wickra_median_price_reset(struct MedianPrice *handle);

void wickra_median_price_free(struct MedianPrice *handle);

struct Mfi *wickra_mfi_new(uintptr_t period);

double wickra_mfi_update(struct Mfi *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_mfi_batch(struct Mfi *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_mfi_warmup_period(struct Mfi *handle);

bool wickra_mfi_is_ready(struct Mfi *handle);

const char *wickra_mfi_name(struct Mfi *handle);

void wickra_mfi_reset(struct Mfi *handle);

void wickra_mfi_free(struct Mfi *handle);

struct MidPrice *wickra_mid_price_new(uintptr_t period);

double wickra_mid_price_update(struct MidPrice *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_mid_price_batch(struct MidPrice *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_mid_price_warmup_period(struct MidPrice *handle);

bool wickra_mid_price_is_ready(struct MidPrice *handle);

const char *wickra_mid_price_name(struct MidPrice *handle);

void wickra_mid_price_reset(struct MidPrice *handle);

void wickra_mid_price_free(struct MidPrice *handle);

struct MinusDi *wickra_minus_di_new(uintptr_t period);

double wickra_minus_di_update(struct MinusDi *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp);

void wickra_minus_di_batch(struct MinusDi *handle,
                           const double *open,
                           const double *high,
                           const double *low,
                           const double *close,
                           const double *volume,
                           const int64_t *timestamp,
                           double *out,
                           uintptr_t n);

uintptr_t wickra_minus_di_warmup_period(struct MinusDi *handle);

bool wickra_minus_di_is_ready(struct MinusDi *handle);

const char *wickra_minus_di_name(struct MinusDi *handle);

void wickra_minus_di_reset(struct MinusDi *handle);

void wickra_minus_di_free(struct MinusDi *handle);

struct MinusDm *wickra_minus_dm_new(uintptr_t period);

double wickra_minus_dm_update(struct MinusDm *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp);

void wickra_minus_dm_batch(struct MinusDm *handle,
                           const double *open,
                           const double *high,
                           const double *low,
                           const double *close,
                           const double *volume,
                           const int64_t *timestamp,
                           double *out,
                           uintptr_t n);

uintptr_t wickra_minus_dm_warmup_period(struct MinusDm *handle);

bool wickra_minus_dm_is_ready(struct MinusDm *handle);

const char *wickra_minus_dm_name(struct MinusDm *handle);

void wickra_minus_dm_reset(struct MinusDm *handle);

void wickra_minus_dm_free(struct MinusDm *handle);

struct MorningDojiStar *wickra_morning_doji_star_new(void);

double wickra_morning_doji_star_update(struct MorningDojiStar *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_morning_doji_star_batch(struct MorningDojiStar *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_morning_doji_star_warmup_period(struct MorningDojiStar *handle);

bool wickra_morning_doji_star_is_ready(struct MorningDojiStar *handle);

const char *wickra_morning_doji_star_name(struct MorningDojiStar *handle);

void wickra_morning_doji_star_reset(struct MorningDojiStar *handle);

void wickra_morning_doji_star_free(struct MorningDojiStar *handle);

struct MorningEveningStar *wickra_morning_evening_star_new(void);

double wickra_morning_evening_star_update(struct MorningEveningStar *handle,
                                          double open,
                                          double high,
                                          double low,
                                          double close,
                                          double volume,
                                          int64_t timestamp);

void wickra_morning_evening_star_batch(struct MorningEveningStar *handle,
                                       const double *open,
                                       const double *high,
                                       const double *low,
                                       const double *close,
                                       const double *volume,
                                       const int64_t *timestamp,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_morning_evening_star_warmup_period(struct MorningEveningStar *handle);

bool wickra_morning_evening_star_is_ready(struct MorningEveningStar *handle);

const char *wickra_morning_evening_star_name(struct MorningEveningStar *handle);

void wickra_morning_evening_star_reset(struct MorningEveningStar *handle);

void wickra_morning_evening_star_free(struct MorningEveningStar *handle);

struct NakedPoc *wickra_naked_poc_new(uintptr_t session_len, uintptr_t bins);

double wickra_naked_poc_update(struct NakedPoc *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_naked_poc_batch(struct NakedPoc *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_naked_poc_warmup_period(struct NakedPoc *handle);

bool wickra_naked_poc_is_ready(struct NakedPoc *handle);

const char *wickra_naked_poc_name(struct NakedPoc *handle);

void wickra_naked_poc_reset(struct NakedPoc *handle);

void wickra_naked_poc_free(struct NakedPoc *handle);

struct Natr *wickra_natr_new(uintptr_t period);

double wickra_natr_update(struct Natr *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp);

void wickra_natr_batch(struct Natr *handle,
                       const double *open,
                       const double *high,
                       const double *low,
                       const double *close,
                       const double *volume,
                       const int64_t *timestamp,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_natr_warmup_period(struct Natr *handle);

bool wickra_natr_is_ready(struct Natr *handle);

const char *wickra_natr_name(struct Natr *handle);

void wickra_natr_reset(struct Natr *handle);

void wickra_natr_free(struct Natr *handle);

struct NewPriceLines *wickra_new_price_lines_new(uintptr_t count);

double wickra_new_price_lines_update(struct NewPriceLines *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp);

void wickra_new_price_lines_batch(struct NewPriceLines *handle,
                                  const double *open,
                                  const double *high,
                                  const double *low,
                                  const double *close,
                                  const double *volume,
                                  const int64_t *timestamp,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_new_price_lines_warmup_period(struct NewPriceLines *handle);

bool wickra_new_price_lines_is_ready(struct NewPriceLines *handle);

const char *wickra_new_price_lines_name(struct NewPriceLines *handle);

void wickra_new_price_lines_reset(struct NewPriceLines *handle);

void wickra_new_price_lines_free(struct NewPriceLines *handle);

struct Nvi *wickra_nvi_new(void);

double wickra_nvi_update(struct Nvi *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_nvi_batch(struct Nvi *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_nvi_warmup_period(struct Nvi *handle);

bool wickra_nvi_is_ready(struct Nvi *handle);

const char *wickra_nvi_name(struct Nvi *handle);

void wickra_nvi_reset(struct Nvi *handle);

void wickra_nvi_free(struct Nvi *handle);

struct Obv *wickra_obv_new(void);

double wickra_obv_update(struct Obv *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_obv_batch(struct Obv *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_obv_warmup_period(struct Obv *handle);

bool wickra_obv_is_ready(struct Obv *handle);

const char *wickra_obv_name(struct Obv *handle);

void wickra_obv_reset(struct Obv *handle);

void wickra_obv_free(struct Obv *handle);

struct OnNeck *wickra_on_neck_new(void);

double wickra_on_neck_update(struct OnNeck *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_on_neck_batch(struct OnNeck *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_on_neck_warmup_period(struct OnNeck *handle);

bool wickra_on_neck_is_ready(struct OnNeck *handle);

const char *wickra_on_neck_name(struct OnNeck *handle);

void wickra_on_neck_reset(struct OnNeck *handle);

void wickra_on_neck_free(struct OnNeck *handle);

struct OpeningMarubozu *wickra_opening_marubozu_new(void);

double wickra_opening_marubozu_update(struct OpeningMarubozu *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_opening_marubozu_batch(struct OpeningMarubozu *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_opening_marubozu_warmup_period(struct OpeningMarubozu *handle);

bool wickra_opening_marubozu_is_ready(struct OpeningMarubozu *handle);

const char *wickra_opening_marubozu_name(struct OpeningMarubozu *handle);

void wickra_opening_marubozu_reset(struct OpeningMarubozu *handle);

void wickra_opening_marubozu_free(struct OpeningMarubozu *handle);

struct OvernightGap *wickra_overnight_gap_new(int32_t utc_offset_minutes);

double wickra_overnight_gap_update(struct OvernightGap *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_overnight_gap_batch(struct OvernightGap *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_overnight_gap_warmup_period(struct OvernightGap *handle);

bool wickra_overnight_gap_is_ready(struct OvernightGap *handle);

const char *wickra_overnight_gap_name(struct OvernightGap *handle);

void wickra_overnight_gap_reset(struct OvernightGap *handle);

void wickra_overnight_gap_free(struct OvernightGap *handle);

struct ParkinsonVolatility *wickra_parkinson_volatility_new(uintptr_t period,
                                                            uintptr_t trading_periods);

double wickra_parkinson_volatility_update(struct ParkinsonVolatility *handle,
                                          double open,
                                          double high,
                                          double low,
                                          double close,
                                          double volume,
                                          int64_t timestamp);

void wickra_parkinson_volatility_batch(struct ParkinsonVolatility *handle,
                                       const double *open,
                                       const double *high,
                                       const double *low,
                                       const double *close,
                                       const double *volume,
                                       const int64_t *timestamp,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_parkinson_volatility_warmup_period(struct ParkinsonVolatility *handle);

bool wickra_parkinson_volatility_is_ready(struct ParkinsonVolatility *handle);

const char *wickra_parkinson_volatility_name(struct ParkinsonVolatility *handle);

void wickra_parkinson_volatility_reset(struct ParkinsonVolatility *handle);

void wickra_parkinson_volatility_free(struct ParkinsonVolatility *handle);

struct Pgo *wickra_pgo_new(uintptr_t period);

double wickra_pgo_update(struct Pgo *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_pgo_batch(struct Pgo *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_pgo_warmup_period(struct Pgo *handle);

bool wickra_pgo_is_ready(struct Pgo *handle);

const char *wickra_pgo_name(struct Pgo *handle);

void wickra_pgo_reset(struct Pgo *handle);

void wickra_pgo_free(struct Pgo *handle);

struct PiercingDarkCloud *wickra_piercing_dark_cloud_new(void);

double wickra_piercing_dark_cloud_update(struct PiercingDarkCloud *handle,
                                         double open,
                                         double high,
                                         double low,
                                         double close,
                                         double volume,
                                         int64_t timestamp);

void wickra_piercing_dark_cloud_batch(struct PiercingDarkCloud *handle,
                                      const double *open,
                                      const double *high,
                                      const double *low,
                                      const double *close,
                                      const double *volume,
                                      const int64_t *timestamp,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_piercing_dark_cloud_warmup_period(struct PiercingDarkCloud *handle);

bool wickra_piercing_dark_cloud_is_ready(struct PiercingDarkCloud *handle);

const char *wickra_piercing_dark_cloud_name(struct PiercingDarkCloud *handle);

void wickra_piercing_dark_cloud_reset(struct PiercingDarkCloud *handle);

void wickra_piercing_dark_cloud_free(struct PiercingDarkCloud *handle);

struct PivotReversal *wickra_pivot_reversal_new(uintptr_t left, uintptr_t right);

double wickra_pivot_reversal_update(struct PivotReversal *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_pivot_reversal_batch(struct PivotReversal *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_pivot_reversal_warmup_period(struct PivotReversal *handle);

bool wickra_pivot_reversal_is_ready(struct PivotReversal *handle);

const char *wickra_pivot_reversal_name(struct PivotReversal *handle);

void wickra_pivot_reversal_reset(struct PivotReversal *handle);

void wickra_pivot_reversal_free(struct PivotReversal *handle);

struct PlusDi *wickra_plus_di_new(uintptr_t period);

double wickra_plus_di_update(struct PlusDi *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_plus_di_batch(struct PlusDi *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_plus_di_warmup_period(struct PlusDi *handle);

bool wickra_plus_di_is_ready(struct PlusDi *handle);

const char *wickra_plus_di_name(struct PlusDi *handle);

void wickra_plus_di_reset(struct PlusDi *handle);

void wickra_plus_di_free(struct PlusDi *handle);

struct PlusDm *wickra_plus_dm_new(uintptr_t period);

double wickra_plus_dm_update(struct PlusDm *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_plus_dm_batch(struct PlusDm *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_plus_dm_warmup_period(struct PlusDm *handle);

bool wickra_plus_dm_is_ready(struct PlusDm *handle);

const char *wickra_plus_dm_name(struct PlusDm *handle);

void wickra_plus_dm_reset(struct PlusDm *handle);

void wickra_plus_dm_free(struct PlusDm *handle);

struct ProfileShape *wickra_profile_shape_new(uintptr_t period, uintptr_t bins);

double wickra_profile_shape_update(struct ProfileShape *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_profile_shape_batch(struct ProfileShape *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_profile_shape_warmup_period(struct ProfileShape *handle);

bool wickra_profile_shape_is_ready(struct ProfileShape *handle);

const char *wickra_profile_shape_name(struct ProfileShape *handle);

void wickra_profile_shape_reset(struct ProfileShape *handle);

void wickra_profile_shape_free(struct ProfileShape *handle);

struct ProjectionOscillator *wickra_projection_oscillator_new(uintptr_t period);

double wickra_projection_oscillator_update(struct ProjectionOscillator *handle,
                                           double open,
                                           double high,
                                           double low,
                                           double close,
                                           double volume,
                                           int64_t timestamp);

void wickra_projection_oscillator_batch(struct ProjectionOscillator *handle,
                                        const double *open,
                                        const double *high,
                                        const double *low,
                                        const double *close,
                                        const double *volume,
                                        const int64_t *timestamp,
                                        double *out,
                                        uintptr_t n);

uintptr_t wickra_projection_oscillator_warmup_period(struct ProjectionOscillator *handle);

bool wickra_projection_oscillator_is_ready(struct ProjectionOscillator *handle);

const char *wickra_projection_oscillator_name(struct ProjectionOscillator *handle);

void wickra_projection_oscillator_reset(struct ProjectionOscillator *handle);

void wickra_projection_oscillator_free(struct ProjectionOscillator *handle);

struct Psar *wickra_psar_new(double af_start, double af_step, double af_max);

double wickra_psar_update(struct Psar *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp);

void wickra_psar_batch(struct Psar *handle,
                       const double *open,
                       const double *high,
                       const double *low,
                       const double *close,
                       const double *volume,
                       const int64_t *timestamp,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_psar_warmup_period(struct Psar *handle);

bool wickra_psar_is_ready(struct Psar *handle);

const char *wickra_psar_name(struct Psar *handle);

void wickra_psar_reset(struct Psar *handle);

void wickra_psar_free(struct Psar *handle);

struct Pvi *wickra_pvi_new(void);

double wickra_pvi_update(struct Pvi *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_pvi_batch(struct Pvi *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_pvi_warmup_period(struct Pvi *handle);

bool wickra_pvi_is_ready(struct Pvi *handle);

const char *wickra_pvi_name(struct Pvi *handle);

void wickra_pvi_reset(struct Pvi *handle);

void wickra_pvi_free(struct Pvi *handle);

struct Qstick *wickra_qstick_new(uintptr_t period);

double wickra_qstick_update(struct Qstick *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp);

void wickra_qstick_batch(struct Qstick *handle,
                         const double *open,
                         const double *high,
                         const double *low,
                         const double *close,
                         const double *volume,
                         const int64_t *timestamp,
                         double *out,
                         uintptr_t n);

uintptr_t wickra_qstick_warmup_period(struct Qstick *handle);

bool wickra_qstick_is_ready(struct Qstick *handle);

const char *wickra_qstick_name(struct Qstick *handle);

void wickra_qstick_reset(struct Qstick *handle);

void wickra_qstick_free(struct Qstick *handle);

struct RectangleRange *wickra_rectangle_range_new(void);

double wickra_rectangle_range_update(struct RectangleRange *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp);

void wickra_rectangle_range_batch(struct RectangleRange *handle,
                                  const double *open,
                                  const double *high,
                                  const double *low,
                                  const double *close,
                                  const double *volume,
                                  const int64_t *timestamp,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_rectangle_range_warmup_period(struct RectangleRange *handle);

bool wickra_rectangle_range_is_ready(struct RectangleRange *handle);

const char *wickra_rectangle_range_name(struct RectangleRange *handle);

void wickra_rectangle_range_reset(struct RectangleRange *handle);

void wickra_rectangle_range_free(struct RectangleRange *handle);

struct RickshawMan *wickra_rickshaw_man_new(void);

double wickra_rickshaw_man_update(struct RickshawMan *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_rickshaw_man_batch(struct RickshawMan *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_rickshaw_man_warmup_period(struct RickshawMan *handle);

bool wickra_rickshaw_man_is_ready(struct RickshawMan *handle);

const char *wickra_rickshaw_man_name(struct RickshawMan *handle);

void wickra_rickshaw_man_reset(struct RickshawMan *handle);

void wickra_rickshaw_man_free(struct RickshawMan *handle);

struct RisingThreeMethods *wickra_rising_three_methods_new(void);

double wickra_rising_three_methods_update(struct RisingThreeMethods *handle,
                                          double open,
                                          double high,
                                          double low,
                                          double close,
                                          double volume,
                                          int64_t timestamp);

void wickra_rising_three_methods_batch(struct RisingThreeMethods *handle,
                                       const double *open,
                                       const double *high,
                                       const double *low,
                                       const double *close,
                                       const double *volume,
                                       const int64_t *timestamp,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_rising_three_methods_warmup_period(struct RisingThreeMethods *handle);

bool wickra_rising_three_methods_is_ready(struct RisingThreeMethods *handle);

const char *wickra_rising_three_methods_name(struct RisingThreeMethods *handle);

void wickra_rising_three_methods_reset(struct RisingThreeMethods *handle);

void wickra_rising_three_methods_free(struct RisingThreeMethods *handle);

struct RogersSatchellVolatility *wickra_rogers_satchell_volatility_new(uintptr_t period,
                                                                       uintptr_t trading_periods);

double wickra_rogers_satchell_volatility_update(struct RogersSatchellVolatility *handle,
                                                double open,
                                                double high,
                                                double low,
                                                double close,
                                                double volume,
                                                int64_t timestamp);

void wickra_rogers_satchell_volatility_batch(struct RogersSatchellVolatility *handle,
                                             const double *open,
                                             const double *high,
                                             const double *low,
                                             const double *close,
                                             const double *volume,
                                             const int64_t *timestamp,
                                             double *out,
                                             uintptr_t n);

uintptr_t wickra_rogers_satchell_volatility_warmup_period(struct RogersSatchellVolatility *handle);

bool wickra_rogers_satchell_volatility_is_ready(struct RogersSatchellVolatility *handle);

const char *wickra_rogers_satchell_volatility_name(struct RogersSatchellVolatility *handle);

void wickra_rogers_satchell_volatility_reset(struct RogersSatchellVolatility *handle);

void wickra_rogers_satchell_volatility_free(struct RogersSatchellVolatility *handle);

struct Rvi *wickra_rvi_new(uintptr_t period);

double wickra_rvi_update(struct Rvi *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_rvi_batch(struct Rvi *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_rvi_warmup_period(struct Rvi *handle);

bool wickra_rvi_is_ready(struct Rvi *handle);

const char *wickra_rvi_name(struct Rvi *handle);

void wickra_rvi_reset(struct Rvi *handle);

void wickra_rvi_free(struct Rvi *handle);

struct SarExt *wickra_sar_ext_new(double start_value,
                                  double offset_on_reverse,
                                  double accel_init_long,
                                  double accel_long,
                                  double accel_max_long,
                                  double accel_init_short,
                                  double accel_short,
                                  double accel_max_short);

double wickra_sar_ext_update(struct SarExt *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_sar_ext_batch(struct SarExt *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_sar_ext_warmup_period(struct SarExt *handle);

bool wickra_sar_ext_is_ready(struct SarExt *handle);

const char *wickra_sar_ext_name(struct SarExt *handle);

void wickra_sar_ext_reset(struct SarExt *handle);

void wickra_sar_ext_free(struct SarExt *handle);

struct SeasonalZScore *wickra_seasonal_z_score_new(int32_t utc_offset_minutes);

double wickra_seasonal_z_score_update(struct SeasonalZScore *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_seasonal_z_score_batch(struct SeasonalZScore *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_seasonal_z_score_warmup_period(struct SeasonalZScore *handle);

bool wickra_seasonal_z_score_is_ready(struct SeasonalZScore *handle);

const char *wickra_seasonal_z_score_name(struct SeasonalZScore *handle);

void wickra_seasonal_z_score_reset(struct SeasonalZScore *handle);

void wickra_seasonal_z_score_free(struct SeasonalZScore *handle);

struct SeparatingLines *wickra_separating_lines_new(void);

double wickra_separating_lines_update(struct SeparatingLines *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_separating_lines_batch(struct SeparatingLines *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_separating_lines_warmup_period(struct SeparatingLines *handle);

bool wickra_separating_lines_is_ready(struct SeparatingLines *handle);

const char *wickra_separating_lines_name(struct SeparatingLines *handle);

void wickra_separating_lines_reset(struct SeparatingLines *handle);

void wickra_separating_lines_free(struct SeparatingLines *handle);

struct SessionVwap *wickra_session_vwap_new(int32_t utc_offset_minutes);

double wickra_session_vwap_update(struct SessionVwap *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_session_vwap_batch(struct SessionVwap *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_session_vwap_warmup_period(struct SessionVwap *handle);

bool wickra_session_vwap_is_ready(struct SessionVwap *handle);

const char *wickra_session_vwap_name(struct SessionVwap *handle);

void wickra_session_vwap_reset(struct SessionVwap *handle);

void wickra_session_vwap_free(struct SessionVwap *handle);

struct Shark *wickra_shark_new(void);

double wickra_shark_update(struct Shark *handle,
                           double open,
                           double high,
                           double low,
                           double close,
                           double volume,
                           int64_t timestamp);

void wickra_shark_batch(struct Shark *handle,
                        const double *open,
                        const double *high,
                        const double *low,
                        const double *close,
                        const double *volume,
                        const int64_t *timestamp,
                        double *out,
                        uintptr_t n);

uintptr_t wickra_shark_warmup_period(struct Shark *handle);

bool wickra_shark_is_ready(struct Shark *handle);

const char *wickra_shark_name(struct Shark *handle);

void wickra_shark_reset(struct Shark *handle);

void wickra_shark_free(struct Shark *handle);

struct ShootingStar *wickra_shooting_star_new(void);

double wickra_shooting_star_update(struct ShootingStar *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_shooting_star_batch(struct ShootingStar *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_shooting_star_warmup_period(struct ShootingStar *handle);

bool wickra_shooting_star_is_ready(struct ShootingStar *handle);

const char *wickra_shooting_star_name(struct ShootingStar *handle);

void wickra_shooting_star_reset(struct ShootingStar *handle);

void wickra_shooting_star_free(struct ShootingStar *handle);

struct ShortLine *wickra_short_line_new(void);

double wickra_short_line_update(struct ShortLine *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_short_line_batch(struct ShortLine *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_short_line_warmup_period(struct ShortLine *handle);

bool wickra_short_line_is_ready(struct ShortLine *handle);

const char *wickra_short_line_name(struct ShortLine *handle);

void wickra_short_line_reset(struct ShortLine *handle);

void wickra_short_line_free(struct ShortLine *handle);

struct SinglePrints *wickra_single_prints_new(uintptr_t period, uintptr_t bins);

double wickra_single_prints_update(struct SinglePrints *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_single_prints_batch(struct SinglePrints *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_single_prints_warmup_period(struct SinglePrints *handle);

bool wickra_single_prints_is_ready(struct SinglePrints *handle);

const char *wickra_single_prints_name(struct SinglePrints *handle);

void wickra_single_prints_reset(struct SinglePrints *handle);

void wickra_single_prints_free(struct SinglePrints *handle);

struct Smi *wickra_smi_new(uintptr_t period, uintptr_t d_period, uintptr_t d2_period);

double wickra_smi_update(struct Smi *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_smi_batch(struct Smi *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_smi_warmup_period(struct Smi *handle);

bool wickra_smi_is_ready(struct Smi *handle);

const char *wickra_smi_name(struct Smi *handle);

void wickra_smi_reset(struct Smi *handle);

void wickra_smi_free(struct Smi *handle);

struct SpinningTop *wickra_spinning_top_new(void);

double wickra_spinning_top_update(struct SpinningTop *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_spinning_top_batch(struct SpinningTop *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_spinning_top_warmup_period(struct SpinningTop *handle);

bool wickra_spinning_top_is_ready(struct SpinningTop *handle);

const char *wickra_spinning_top_name(struct SpinningTop *handle);

void wickra_spinning_top_reset(struct SpinningTop *handle);

void wickra_spinning_top_free(struct SpinningTop *handle);

struct StalledPattern *wickra_stalled_pattern_new(void);

double wickra_stalled_pattern_update(struct StalledPattern *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp);

void wickra_stalled_pattern_batch(struct StalledPattern *handle,
                                  const double *open,
                                  const double *high,
                                  const double *low,
                                  const double *close,
                                  const double *volume,
                                  const int64_t *timestamp,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_stalled_pattern_warmup_period(struct StalledPattern *handle);

bool wickra_stalled_pattern_is_ready(struct StalledPattern *handle);

const char *wickra_stalled_pattern_name(struct StalledPattern *handle);

void wickra_stalled_pattern_reset(struct StalledPattern *handle);

void wickra_stalled_pattern_free(struct StalledPattern *handle);

struct StickSandwich *wickra_stick_sandwich_new(void);

double wickra_stick_sandwich_update(struct StickSandwich *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_stick_sandwich_batch(struct StickSandwich *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_stick_sandwich_warmup_period(struct StickSandwich *handle);

bool wickra_stick_sandwich_is_ready(struct StickSandwich *handle);

const char *wickra_stick_sandwich_name(struct StickSandwich *handle);

void wickra_stick_sandwich_reset(struct StickSandwich *handle);

void wickra_stick_sandwich_free(struct StickSandwich *handle);

struct StochasticCci *wickra_stochastic_cci_new(uintptr_t period);

double wickra_stochastic_cci_update(struct StochasticCci *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_stochastic_cci_batch(struct StochasticCci *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_stochastic_cci_warmup_period(struct StochasticCci *handle);

bool wickra_stochastic_cci_is_ready(struct StochasticCci *handle);

const char *wickra_stochastic_cci_name(struct StochasticCci *handle);

void wickra_stochastic_cci_reset(struct StochasticCci *handle);

void wickra_stochastic_cci_free(struct StochasticCci *handle);

struct Takuri *wickra_takuri_new(void);

double wickra_takuri_update(struct Takuri *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp);

void wickra_takuri_batch(struct Takuri *handle,
                         const double *open,
                         const double *high,
                         const double *low,
                         const double *close,
                         const double *volume,
                         const int64_t *timestamp,
                         double *out,
                         uintptr_t n);

uintptr_t wickra_takuri_warmup_period(struct Takuri *handle);

bool wickra_takuri_is_ready(struct Takuri *handle);

const char *wickra_takuri_name(struct Takuri *handle);

void wickra_takuri_reset(struct Takuri *handle);

void wickra_takuri_free(struct Takuri *handle);

struct TasukiGap *wickra_tasuki_gap_new(void);

double wickra_tasuki_gap_update(struct TasukiGap *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_tasuki_gap_batch(struct TasukiGap *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_tasuki_gap_warmup_period(struct TasukiGap *handle);

bool wickra_tasuki_gap_is_ready(struct TasukiGap *handle);

const char *wickra_tasuki_gap_name(struct TasukiGap *handle);

void wickra_tasuki_gap_reset(struct TasukiGap *handle);

void wickra_tasuki_gap_free(struct TasukiGap *handle);

struct TdCamouflage *wickra_td_camouflage_new(void);

double wickra_td_camouflage_update(struct TdCamouflage *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_td_camouflage_batch(struct TdCamouflage *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_td_camouflage_warmup_period(struct TdCamouflage *handle);

bool wickra_td_camouflage_is_ready(struct TdCamouflage *handle);

const char *wickra_td_camouflage_name(struct TdCamouflage *handle);

void wickra_td_camouflage_reset(struct TdCamouflage *handle);

void wickra_td_camouflage_free(struct TdCamouflage *handle);

struct TdClop *wickra_td_clop_new(void);

double wickra_td_clop_update(struct TdClop *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_td_clop_batch(struct TdClop *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_td_clop_warmup_period(struct TdClop *handle);

bool wickra_td_clop_is_ready(struct TdClop *handle);

const char *wickra_td_clop_name(struct TdClop *handle);

void wickra_td_clop_reset(struct TdClop *handle);

void wickra_td_clop_free(struct TdClop *handle);

struct TdClopwin *wickra_td_clopwin_new(void);

double wickra_td_clopwin_update(struct TdClopwin *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_td_clopwin_batch(struct TdClopwin *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_td_clopwin_warmup_period(struct TdClopwin *handle);

bool wickra_td_clopwin_is_ready(struct TdClopwin *handle);

const char *wickra_td_clopwin_name(struct TdClopwin *handle);

void wickra_td_clopwin_reset(struct TdClopwin *handle);

void wickra_td_clopwin_free(struct TdClopwin *handle);

struct TdCombo *wickra_td_combo_new(uintptr_t setup_lookback,
                                    uintptr_t setup_target,
                                    uintptr_t countdown_lookback,
                                    uintptr_t countdown_target);

double wickra_td_combo_update(struct TdCombo *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp);

void wickra_td_combo_batch(struct TdCombo *handle,
                           const double *open,
                           const double *high,
                           const double *low,
                           const double *close,
                           const double *volume,
                           const int64_t *timestamp,
                           double *out,
                           uintptr_t n);

uintptr_t wickra_td_combo_warmup_period(struct TdCombo *handle);

bool wickra_td_combo_is_ready(struct TdCombo *handle);

const char *wickra_td_combo_name(struct TdCombo *handle);

void wickra_td_combo_reset(struct TdCombo *handle);

void wickra_td_combo_free(struct TdCombo *handle);

struct TdCountdown *wickra_td_countdown_new(uintptr_t setup_lookback,
                                            uintptr_t setup_target,
                                            uintptr_t countdown_lookback,
                                            uintptr_t countdown_target);

double wickra_td_countdown_update(struct TdCountdown *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_td_countdown_batch(struct TdCountdown *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_td_countdown_warmup_period(struct TdCountdown *handle);

bool wickra_td_countdown_is_ready(struct TdCountdown *handle);

const char *wickra_td_countdown_name(struct TdCountdown *handle);

void wickra_td_countdown_reset(struct TdCountdown *handle);

void wickra_td_countdown_free(struct TdCountdown *handle);

struct TdDeMarker *wickra_td_de_marker_new(uintptr_t period);

double wickra_td_de_marker_update(struct TdDeMarker *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_td_de_marker_batch(struct TdDeMarker *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_td_de_marker_warmup_period(struct TdDeMarker *handle);

bool wickra_td_de_marker_is_ready(struct TdDeMarker *handle);

const char *wickra_td_de_marker_name(struct TdDeMarker *handle);

void wickra_td_de_marker_reset(struct TdDeMarker *handle);

void wickra_td_de_marker_free(struct TdDeMarker *handle);

struct TdDifferential *wickra_td_differential_new(void);

double wickra_td_differential_update(struct TdDifferential *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp);

void wickra_td_differential_batch(struct TdDifferential *handle,
                                  const double *open,
                                  const double *high,
                                  const double *low,
                                  const double *close,
                                  const double *volume,
                                  const int64_t *timestamp,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_td_differential_warmup_period(struct TdDifferential *handle);

bool wickra_td_differential_is_ready(struct TdDifferential *handle);

const char *wickra_td_differential_name(struct TdDifferential *handle);

void wickra_td_differential_reset(struct TdDifferential *handle);

void wickra_td_differential_free(struct TdDifferential *handle);

struct TdDWave *wickra_td_d_wave_new(uintptr_t strength);

double wickra_td_d_wave_update(struct TdDWave *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_td_d_wave_batch(struct TdDWave *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_td_d_wave_warmup_period(struct TdDWave *handle);

bool wickra_td_d_wave_is_ready(struct TdDWave *handle);

const char *wickra_td_d_wave_name(struct TdDWave *handle);

void wickra_td_d_wave_reset(struct TdDWave *handle);

void wickra_td_d_wave_free(struct TdDWave *handle);

struct TdOpen *wickra_td_open_new(void);

double wickra_td_open_update(struct TdOpen *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_td_open_batch(struct TdOpen *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_td_open_warmup_period(struct TdOpen *handle);

bool wickra_td_open_is_ready(struct TdOpen *handle);

const char *wickra_td_open_name(struct TdOpen *handle);

void wickra_td_open_reset(struct TdOpen *handle);

void wickra_td_open_free(struct TdOpen *handle);

struct TdPressure *wickra_td_pressure_new(uintptr_t period);

double wickra_td_pressure_update(struct TdPressure *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp);

void wickra_td_pressure_batch(struct TdPressure *handle,
                              const double *open,
                              const double *high,
                              const double *low,
                              const double *close,
                              const double *volume,
                              const int64_t *timestamp,
                              double *out,
                              uintptr_t n);

uintptr_t wickra_td_pressure_warmup_period(struct TdPressure *handle);

bool wickra_td_pressure_is_ready(struct TdPressure *handle);

const char *wickra_td_pressure_name(struct TdPressure *handle);

void wickra_td_pressure_reset(struct TdPressure *handle);

void wickra_td_pressure_free(struct TdPressure *handle);

struct TdPropulsion *wickra_td_propulsion_new(void);

double wickra_td_propulsion_update(struct TdPropulsion *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_td_propulsion_batch(struct TdPropulsion *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_td_propulsion_warmup_period(struct TdPropulsion *handle);

bool wickra_td_propulsion_is_ready(struct TdPropulsion *handle);

const char *wickra_td_propulsion_name(struct TdPropulsion *handle);

void wickra_td_propulsion_reset(struct TdPropulsion *handle);

void wickra_td_propulsion_free(struct TdPropulsion *handle);

struct TdRei *wickra_td_rei_new(uintptr_t period);

double wickra_td_rei_update(struct TdRei *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp);

void wickra_td_rei_batch(struct TdRei *handle,
                         const double *open,
                         const double *high,
                         const double *low,
                         const double *close,
                         const double *volume,
                         const int64_t *timestamp,
                         double *out,
                         uintptr_t n);

uintptr_t wickra_td_rei_warmup_period(struct TdRei *handle);

bool wickra_td_rei_is_ready(struct TdRei *handle);

const char *wickra_td_rei_name(struct TdRei *handle);

void wickra_td_rei_reset(struct TdRei *handle);

void wickra_td_rei_free(struct TdRei *handle);

struct TdSetup *wickra_td_setup_new(uintptr_t lookback, uintptr_t target);

double wickra_td_setup_update(struct TdSetup *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp);

void wickra_td_setup_batch(struct TdSetup *handle,
                           const double *open,
                           const double *high,
                           const double *low,
                           const double *close,
                           const double *volume,
                           const int64_t *timestamp,
                           double *out,
                           uintptr_t n);

uintptr_t wickra_td_setup_warmup_period(struct TdSetup *handle);

bool wickra_td_setup_is_ready(struct TdSetup *handle);

const char *wickra_td_setup_name(struct TdSetup *handle);

void wickra_td_setup_reset(struct TdSetup *handle);

void wickra_td_setup_free(struct TdSetup *handle);

struct TdTrap *wickra_td_trap_new(void);

double wickra_td_trap_update(struct TdTrap *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_td_trap_batch(struct TdTrap *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_td_trap_warmup_period(struct TdTrap *handle);

bool wickra_td_trap_is_ready(struct TdTrap *handle);

const char *wickra_td_trap_name(struct TdTrap *handle);

void wickra_td_trap_reset(struct TdTrap *handle);

void wickra_td_trap_free(struct TdTrap *handle);

struct ThreeDrives *wickra_three_drives_new(void);

double wickra_three_drives_update(struct ThreeDrives *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_three_drives_batch(struct ThreeDrives *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_three_drives_warmup_period(struct ThreeDrives *handle);

bool wickra_three_drives_is_ready(struct ThreeDrives *handle);

const char *wickra_three_drives_name(struct ThreeDrives *handle);

void wickra_three_drives_reset(struct ThreeDrives *handle);

void wickra_three_drives_free(struct ThreeDrives *handle);

struct ThreeInside *wickra_three_inside_new(void);

double wickra_three_inside_update(struct ThreeInside *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_three_inside_batch(struct ThreeInside *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_three_inside_warmup_period(struct ThreeInside *handle);

bool wickra_three_inside_is_ready(struct ThreeInside *handle);

const char *wickra_three_inside_name(struct ThreeInside *handle);

void wickra_three_inside_reset(struct ThreeInside *handle);

void wickra_three_inside_free(struct ThreeInside *handle);

struct ThreeLineBreak *wickra_three_line_break_new(uintptr_t lines);

double wickra_three_line_break_update(struct ThreeLineBreak *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_three_line_break_batch(struct ThreeLineBreak *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_three_line_break_warmup_period(struct ThreeLineBreak *handle);

bool wickra_three_line_break_is_ready(struct ThreeLineBreak *handle);

const char *wickra_three_line_break_name(struct ThreeLineBreak *handle);

void wickra_three_line_break_reset(struct ThreeLineBreak *handle);

void wickra_three_line_break_free(struct ThreeLineBreak *handle);

struct ThreeLineStrike *wickra_three_line_strike_new(void);

double wickra_three_line_strike_update(struct ThreeLineStrike *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_three_line_strike_batch(struct ThreeLineStrike *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_three_line_strike_warmup_period(struct ThreeLineStrike *handle);

bool wickra_three_line_strike_is_ready(struct ThreeLineStrike *handle);

const char *wickra_three_line_strike_name(struct ThreeLineStrike *handle);

void wickra_three_line_strike_reset(struct ThreeLineStrike *handle);

void wickra_three_line_strike_free(struct ThreeLineStrike *handle);

struct ThreeOutside *wickra_three_outside_new(void);

double wickra_three_outside_update(struct ThreeOutside *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_three_outside_batch(struct ThreeOutside *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_three_outside_warmup_period(struct ThreeOutside *handle);

bool wickra_three_outside_is_ready(struct ThreeOutside *handle);

const char *wickra_three_outside_name(struct ThreeOutside *handle);

void wickra_three_outside_reset(struct ThreeOutside *handle);

void wickra_three_outside_free(struct ThreeOutside *handle);

struct ThreeSoldiersOrCrows *wickra_three_soldiers_or_crows_new(void);

double wickra_three_soldiers_or_crows_update(struct ThreeSoldiersOrCrows *handle,
                                             double open,
                                             double high,
                                             double low,
                                             double close,
                                             double volume,
                                             int64_t timestamp);

void wickra_three_soldiers_or_crows_batch(struct ThreeSoldiersOrCrows *handle,
                                          const double *open,
                                          const double *high,
                                          const double *low,
                                          const double *close,
                                          const double *volume,
                                          const int64_t *timestamp,
                                          double *out,
                                          uintptr_t n);

uintptr_t wickra_three_soldiers_or_crows_warmup_period(struct ThreeSoldiersOrCrows *handle);

bool wickra_three_soldiers_or_crows_is_ready(struct ThreeSoldiersOrCrows *handle);

const char *wickra_three_soldiers_or_crows_name(struct ThreeSoldiersOrCrows *handle);

void wickra_three_soldiers_or_crows_reset(struct ThreeSoldiersOrCrows *handle);

void wickra_three_soldiers_or_crows_free(struct ThreeSoldiersOrCrows *handle);

struct ThreeStarsInSouth *wickra_three_stars_in_south_new(void);

double wickra_three_stars_in_south_update(struct ThreeStarsInSouth *handle,
                                          double open,
                                          double high,
                                          double low,
                                          double close,
                                          double volume,
                                          int64_t timestamp);

void wickra_three_stars_in_south_batch(struct ThreeStarsInSouth *handle,
                                       const double *open,
                                       const double *high,
                                       const double *low,
                                       const double *close,
                                       const double *volume,
                                       const int64_t *timestamp,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_three_stars_in_south_warmup_period(struct ThreeStarsInSouth *handle);

bool wickra_three_stars_in_south_is_ready(struct ThreeStarsInSouth *handle);

const char *wickra_three_stars_in_south_name(struct ThreeStarsInSouth *handle);

void wickra_three_stars_in_south_reset(struct ThreeStarsInSouth *handle);

void wickra_three_stars_in_south_free(struct ThreeStarsInSouth *handle);

struct Thrusting *wickra_thrusting_new(void);

double wickra_thrusting_update(struct Thrusting *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_thrusting_batch(struct Thrusting *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_thrusting_warmup_period(struct Thrusting *handle);

bool wickra_thrusting_is_ready(struct Thrusting *handle);

const char *wickra_thrusting_name(struct Thrusting *handle);

void wickra_thrusting_reset(struct Thrusting *handle);

void wickra_thrusting_free(struct Thrusting *handle);

struct TimeBasedStop *wickra_time_based_stop_new(uintptr_t max_bars);

double wickra_time_based_stop_update(struct TimeBasedStop *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp);

void wickra_time_based_stop_batch(struct TimeBasedStop *handle,
                                  const double *open,
                                  const double *high,
                                  const double *low,
                                  const double *close,
                                  const double *volume,
                                  const int64_t *timestamp,
                                  double *out,
                                  uintptr_t n);

uintptr_t wickra_time_based_stop_warmup_period(struct TimeBasedStop *handle);

bool wickra_time_based_stop_is_ready(struct TimeBasedStop *handle);

const char *wickra_time_based_stop_name(struct TimeBasedStop *handle);

void wickra_time_based_stop_reset(struct TimeBasedStop *handle);

void wickra_time_based_stop_free(struct TimeBasedStop *handle);

struct TowerTopBottom *wickra_tower_top_bottom_new(void);

double wickra_tower_top_bottom_update(struct TowerTopBottom *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_tower_top_bottom_batch(struct TowerTopBottom *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_tower_top_bottom_warmup_period(struct TowerTopBottom *handle);

bool wickra_tower_top_bottom_is_ready(struct TowerTopBottom *handle);

const char *wickra_tower_top_bottom_name(struct TowerTopBottom *handle);

void wickra_tower_top_bottom_reset(struct TowerTopBottom *handle);

void wickra_tower_top_bottom_free(struct TowerTopBottom *handle);

struct TradeVolumeIndex *wickra_trade_volume_index_new(double min_tick);

double wickra_trade_volume_index_update(struct TradeVolumeIndex *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_trade_volume_index_batch(struct TradeVolumeIndex *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_trade_volume_index_warmup_period(struct TradeVolumeIndex *handle);

bool wickra_trade_volume_index_is_ready(struct TradeVolumeIndex *handle);

const char *wickra_trade_volume_index_name(struct TradeVolumeIndex *handle);

void wickra_trade_volume_index_reset(struct TradeVolumeIndex *handle);

void wickra_trade_volume_index_free(struct TradeVolumeIndex *handle);

struct Triangle *wickra_triangle_new(void);

double wickra_triangle_update(struct Triangle *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp);

void wickra_triangle_batch(struct Triangle *handle,
                           const double *open,
                           const double *high,
                           const double *low,
                           const double *close,
                           const double *volume,
                           const int64_t *timestamp,
                           double *out,
                           uintptr_t n);

uintptr_t wickra_triangle_warmup_period(struct Triangle *handle);

bool wickra_triangle_is_ready(struct Triangle *handle);

const char *wickra_triangle_name(struct Triangle *handle);

void wickra_triangle_reset(struct Triangle *handle);

void wickra_triangle_free(struct Triangle *handle);

struct TripleTopBottom *wickra_triple_top_bottom_new(void);

double wickra_triple_top_bottom_update(struct TripleTopBottom *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_triple_top_bottom_batch(struct TripleTopBottom *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_triple_top_bottom_warmup_period(struct TripleTopBottom *handle);

bool wickra_triple_top_bottom_is_ready(struct TripleTopBottom *handle);

const char *wickra_triple_top_bottom_name(struct TripleTopBottom *handle);

void wickra_triple_top_bottom_reset(struct TripleTopBottom *handle);

void wickra_triple_top_bottom_free(struct TripleTopBottom *handle);

struct Tristar *wickra_tristar_new(void);

double wickra_tristar_update(struct Tristar *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_tristar_batch(struct Tristar *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_tristar_warmup_period(struct Tristar *handle);

bool wickra_tristar_is_ready(struct Tristar *handle);

const char *wickra_tristar_name(struct Tristar *handle);

void wickra_tristar_reset(struct Tristar *handle);

void wickra_tristar_free(struct Tristar *handle);

struct TrueRange *wickra_true_range_new(void);

double wickra_true_range_update(struct TrueRange *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_true_range_batch(struct TrueRange *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_true_range_warmup_period(struct TrueRange *handle);

bool wickra_true_range_is_ready(struct TrueRange *handle);

const char *wickra_true_range_name(struct TrueRange *handle);

void wickra_true_range_reset(struct TrueRange *handle);

void wickra_true_range_free(struct TrueRange *handle);

struct Tsv *wickra_tsv_new(uintptr_t period);

double wickra_tsv_update(struct Tsv *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_tsv_batch(struct Tsv *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_tsv_warmup_period(struct Tsv *handle);

bool wickra_tsv_is_ready(struct Tsv *handle);

const char *wickra_tsv_name(struct Tsv *handle);

void wickra_tsv_reset(struct Tsv *handle);

void wickra_tsv_free(struct Tsv *handle);

struct TtmTrend *wickra_ttm_trend_new(uintptr_t period);

double wickra_ttm_trend_update(struct TtmTrend *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_ttm_trend_batch(struct TtmTrend *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_ttm_trend_warmup_period(struct TtmTrend *handle);

bool wickra_ttm_trend_is_ready(struct TtmTrend *handle);

const char *wickra_ttm_trend_name(struct TtmTrend *handle);

void wickra_ttm_trend_reset(struct TtmTrend *handle);

void wickra_ttm_trend_free(struct TtmTrend *handle);

struct TurnOfMonth *wickra_turn_of_month_new(uint32_t n_first,
                                             uint32_t n_last,
                                             int32_t utc_offset_minutes);

double wickra_turn_of_month_update(struct TurnOfMonth *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_turn_of_month_batch(struct TurnOfMonth *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_turn_of_month_warmup_period(struct TurnOfMonth *handle);

bool wickra_turn_of_month_is_ready(struct TurnOfMonth *handle);

const char *wickra_turn_of_month_name(struct TurnOfMonth *handle);

void wickra_turn_of_month_reset(struct TurnOfMonth *handle);

void wickra_turn_of_month_free(struct TurnOfMonth *handle);

struct Tweezer *wickra_tweezer_new(void);

double wickra_tweezer_update(struct Tweezer *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp);

void wickra_tweezer_batch(struct Tweezer *handle,
                          const double *open,
                          const double *high,
                          const double *low,
                          const double *close,
                          const double *volume,
                          const int64_t *timestamp,
                          double *out,
                          uintptr_t n);

uintptr_t wickra_tweezer_warmup_period(struct Tweezer *handle);

bool wickra_tweezer_is_ready(struct Tweezer *handle);

const char *wickra_tweezer_name(struct Tweezer *handle);

void wickra_tweezer_reset(struct Tweezer *handle);

void wickra_tweezer_free(struct Tweezer *handle);

struct TwiggsMoneyFlow *wickra_twiggs_money_flow_new(uintptr_t period);

double wickra_twiggs_money_flow_update(struct TwiggsMoneyFlow *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_twiggs_money_flow_batch(struct TwiggsMoneyFlow *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_twiggs_money_flow_warmup_period(struct TwiggsMoneyFlow *handle);

bool wickra_twiggs_money_flow_is_ready(struct TwiggsMoneyFlow *handle);

const char *wickra_twiggs_money_flow_name(struct TwiggsMoneyFlow *handle);

void wickra_twiggs_money_flow_reset(struct TwiggsMoneyFlow *handle);

void wickra_twiggs_money_flow_free(struct TwiggsMoneyFlow *handle);

struct TwoCrows *wickra_two_crows_new(void);

double wickra_two_crows_update(struct TwoCrows *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_two_crows_batch(struct TwoCrows *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_two_crows_warmup_period(struct TwoCrows *handle);

bool wickra_two_crows_is_ready(struct TwoCrows *handle);

const char *wickra_two_crows_name(struct TwoCrows *handle);

void wickra_two_crows_reset(struct TwoCrows *handle);

void wickra_two_crows_free(struct TwoCrows *handle);

struct TypicalPrice *wickra_typical_price_new(void);

double wickra_typical_price_update(struct TypicalPrice *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp);

void wickra_typical_price_batch(struct TypicalPrice *handle,
                                const double *open,
                                const double *high,
                                const double *low,
                                const double *close,
                                const double *volume,
                                const int64_t *timestamp,
                                double *out,
                                uintptr_t n);

uintptr_t wickra_typical_price_warmup_period(struct TypicalPrice *handle);

bool wickra_typical_price_is_ready(struct TypicalPrice *handle);

const char *wickra_typical_price_name(struct TypicalPrice *handle);

void wickra_typical_price_reset(struct TypicalPrice *handle);

void wickra_typical_price_free(struct TypicalPrice *handle);

struct UltimateOscillator *wickra_ultimate_oscillator_new(uintptr_t short_,
                                                          uintptr_t mid,
                                                          uintptr_t long_);

double wickra_ultimate_oscillator_update(struct UltimateOscillator *handle,
                                         double open,
                                         double high,
                                         double low,
                                         double close,
                                         double volume,
                                         int64_t timestamp);

void wickra_ultimate_oscillator_batch(struct UltimateOscillator *handle,
                                      const double *open,
                                      const double *high,
                                      const double *low,
                                      const double *close,
                                      const double *volume,
                                      const int64_t *timestamp,
                                      double *out,
                                      uintptr_t n);

uintptr_t wickra_ultimate_oscillator_warmup_period(struct UltimateOscillator *handle);

bool wickra_ultimate_oscillator_is_ready(struct UltimateOscillator *handle);

const char *wickra_ultimate_oscillator_name(struct UltimateOscillator *handle);

void wickra_ultimate_oscillator_reset(struct UltimateOscillator *handle);

void wickra_ultimate_oscillator_free(struct UltimateOscillator *handle);

struct UniqueThreeRiver *wickra_unique_three_river_new(void);

double wickra_unique_three_river_update(struct UniqueThreeRiver *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_unique_three_river_batch(struct UniqueThreeRiver *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_unique_three_river_warmup_period(struct UniqueThreeRiver *handle);

bool wickra_unique_three_river_is_ready(struct UniqueThreeRiver *handle);

const char *wickra_unique_three_river_name(struct UniqueThreeRiver *handle);

void wickra_unique_three_river_reset(struct UniqueThreeRiver *handle);

void wickra_unique_three_river_free(struct UniqueThreeRiver *handle);

struct UpsideGapThreeMethods *wickra_upside_gap_three_methods_new(void);

double wickra_upside_gap_three_methods_update(struct UpsideGapThreeMethods *handle,
                                              double open,
                                              double high,
                                              double low,
                                              double close,
                                              double volume,
                                              int64_t timestamp);

void wickra_upside_gap_three_methods_batch(struct UpsideGapThreeMethods *handle,
                                           const double *open,
                                           const double *high,
                                           const double *low,
                                           const double *close,
                                           const double *volume,
                                           const int64_t *timestamp,
                                           double *out,
                                           uintptr_t n);

uintptr_t wickra_upside_gap_three_methods_warmup_period(struct UpsideGapThreeMethods *handle);

bool wickra_upside_gap_three_methods_is_ready(struct UpsideGapThreeMethods *handle);

const char *wickra_upside_gap_three_methods_name(struct UpsideGapThreeMethods *handle);

void wickra_upside_gap_three_methods_reset(struct UpsideGapThreeMethods *handle);

void wickra_upside_gap_three_methods_free(struct UpsideGapThreeMethods *handle);

struct UpsideGapTwoCrows *wickra_upside_gap_two_crows_new(void);

double wickra_upside_gap_two_crows_update(struct UpsideGapTwoCrows *handle,
                                          double open,
                                          double high,
                                          double low,
                                          double close,
                                          double volume,
                                          int64_t timestamp);

void wickra_upside_gap_two_crows_batch(struct UpsideGapTwoCrows *handle,
                                       const double *open,
                                       const double *high,
                                       const double *low,
                                       const double *close,
                                       const double *volume,
                                       const int64_t *timestamp,
                                       double *out,
                                       uintptr_t n);

uintptr_t wickra_upside_gap_two_crows_warmup_period(struct UpsideGapTwoCrows *handle);

bool wickra_upside_gap_two_crows_is_ready(struct UpsideGapTwoCrows *handle);

const char *wickra_upside_gap_two_crows_name(struct UpsideGapTwoCrows *handle);

void wickra_upside_gap_two_crows_reset(struct UpsideGapTwoCrows *handle);

void wickra_upside_gap_two_crows_free(struct UpsideGapTwoCrows *handle);

struct VolatilityRatio *wickra_volatility_ratio_new(uintptr_t period);

double wickra_volatility_ratio_update(struct VolatilityRatio *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp);

void wickra_volatility_ratio_batch(struct VolatilityRatio *handle,
                                   const double *open,
                                   const double *high,
                                   const double *low,
                                   const double *close,
                                   const double *volume,
                                   const int64_t *timestamp,
                                   double *out,
                                   uintptr_t n);

uintptr_t wickra_volatility_ratio_warmup_period(struct VolatilityRatio *handle);

bool wickra_volatility_ratio_is_ready(struct VolatilityRatio *handle);

const char *wickra_volatility_ratio_name(struct VolatilityRatio *handle);

void wickra_volatility_ratio_reset(struct VolatilityRatio *handle);

void wickra_volatility_ratio_free(struct VolatilityRatio *handle);

struct VoltyStop *wickra_volty_stop_new(uintptr_t atr_period, double multiplier);

double wickra_volty_stop_update(struct VoltyStop *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_volty_stop_batch(struct VoltyStop *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_volty_stop_warmup_period(struct VoltyStop *handle);

bool wickra_volty_stop_is_ready(struct VoltyStop *handle);

const char *wickra_volty_stop_name(struct VoltyStop *handle);

void wickra_volty_stop_reset(struct VoltyStop *handle);

void wickra_volty_stop_free(struct VoltyStop *handle);

struct VolumeOscillator *wickra_volume_oscillator_new(uintptr_t fast, uintptr_t slow);

double wickra_volume_oscillator_update(struct VolumeOscillator *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp);

void wickra_volume_oscillator_batch(struct VolumeOscillator *handle,
                                    const double *open,
                                    const double *high,
                                    const double *low,
                                    const double *close,
                                    const double *volume,
                                    const int64_t *timestamp,
                                    double *out,
                                    uintptr_t n);

uintptr_t wickra_volume_oscillator_warmup_period(struct VolumeOscillator *handle);

bool wickra_volume_oscillator_is_ready(struct VolumeOscillator *handle);

const char *wickra_volume_oscillator_name(struct VolumeOscillator *handle);

void wickra_volume_oscillator_reset(struct VolumeOscillator *handle);

void wickra_volume_oscillator_free(struct VolumeOscillator *handle);

struct VolumeRsi *wickra_volume_rsi_new(uintptr_t period);

double wickra_volume_rsi_update(struct VolumeRsi *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_volume_rsi_batch(struct VolumeRsi *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_volume_rsi_warmup_period(struct VolumeRsi *handle);

bool wickra_volume_rsi_is_ready(struct VolumeRsi *handle);

const char *wickra_volume_rsi_name(struct VolumeRsi *handle);

void wickra_volume_rsi_reset(struct VolumeRsi *handle);

void wickra_volume_rsi_free(struct VolumeRsi *handle);

struct VolumePriceTrend *wickra_volume_price_trend_new(void);

double wickra_volume_price_trend_update(struct VolumePriceTrend *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp);

void wickra_volume_price_trend_batch(struct VolumePriceTrend *handle,
                                     const double *open,
                                     const double *high,
                                     const double *low,
                                     const double *close,
                                     const double *volume,
                                     const int64_t *timestamp,
                                     double *out,
                                     uintptr_t n);

uintptr_t wickra_volume_price_trend_warmup_period(struct VolumePriceTrend *handle);

bool wickra_volume_price_trend_is_ready(struct VolumePriceTrend *handle);

const char *wickra_volume_price_trend_name(struct VolumePriceTrend *handle);

void wickra_volume_price_trend_reset(struct VolumePriceTrend *handle);

void wickra_volume_price_trend_free(struct VolumePriceTrend *handle);

struct Vwap *wickra_vwap_new(void);

double wickra_vwap_update(struct Vwap *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp);

void wickra_vwap_batch(struct Vwap *handle,
                       const double *open,
                       const double *high,
                       const double *low,
                       const double *close,
                       const double *volume,
                       const int64_t *timestamp,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_vwap_warmup_period(struct Vwap *handle);

bool wickra_vwap_is_ready(struct Vwap *handle);

const char *wickra_vwap_name(struct Vwap *handle);

void wickra_vwap_reset(struct Vwap *handle);

void wickra_vwap_free(struct Vwap *handle);

struct RollingVwap *wickra_rolling_vwap_new(uintptr_t period);

double wickra_rolling_vwap_update(struct RollingVwap *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp);

void wickra_rolling_vwap_batch(struct RollingVwap *handle,
                               const double *open,
                               const double *high,
                               const double *low,
                               const double *close,
                               const double *volume,
                               const int64_t *timestamp,
                               double *out,
                               uintptr_t n);

uintptr_t wickra_rolling_vwap_warmup_period(struct RollingVwap *handle);

bool wickra_rolling_vwap_is_ready(struct RollingVwap *handle);

const char *wickra_rolling_vwap_name(struct RollingVwap *handle);

void wickra_rolling_vwap_reset(struct RollingVwap *handle);

void wickra_rolling_vwap_free(struct RollingVwap *handle);

struct Vwma *wickra_vwma_new(uintptr_t period);

double wickra_vwma_update(struct Vwma *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp);

void wickra_vwma_batch(struct Vwma *handle,
                       const double *open,
                       const double *high,
                       const double *low,
                       const double *close,
                       const double *volume,
                       const int64_t *timestamp,
                       double *out,
                       uintptr_t n);

uintptr_t wickra_vwma_warmup_period(struct Vwma *handle);

bool wickra_vwma_is_ready(struct Vwma *handle);

const char *wickra_vwma_name(struct Vwma *handle);

void wickra_vwma_reset(struct Vwma *handle);

void wickra_vwma_free(struct Vwma *handle);

struct Vzo *wickra_vzo_new(uintptr_t period);

double wickra_vzo_update(struct Vzo *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_vzo_batch(struct Vzo *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_vzo_warmup_period(struct Vzo *handle);

bool wickra_vzo_is_ready(struct Vzo *handle);

const char *wickra_vzo_name(struct Vzo *handle);

void wickra_vzo_reset(struct Vzo *handle);

void wickra_vzo_free(struct Vzo *handle);

struct Wad *wickra_wad_new(void);

double wickra_wad_update(struct Wad *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp);

void wickra_wad_batch(struct Wad *handle,
                      const double *open,
                      const double *high,
                      const double *low,
                      const double *close,
                      const double *volume,
                      const int64_t *timestamp,
                      double *out,
                      uintptr_t n);

uintptr_t wickra_wad_warmup_period(struct Wad *handle);

bool wickra_wad_is_ready(struct Wad *handle);

const char *wickra_wad_name(struct Wad *handle);

void wickra_wad_reset(struct Wad *handle);

void wickra_wad_free(struct Wad *handle);

struct Wedge *wickra_wedge_new(void);

double wickra_wedge_update(struct Wedge *handle,
                           double open,
                           double high,
                           double low,
                           double close,
                           double volume,
                           int64_t timestamp);

void wickra_wedge_batch(struct Wedge *handle,
                        const double *open,
                        const double *high,
                        const double *low,
                        const double *close,
                        const double *volume,
                        const int64_t *timestamp,
                        double *out,
                        uintptr_t n);

uintptr_t wickra_wedge_warmup_period(struct Wedge *handle);

bool wickra_wedge_is_ready(struct Wedge *handle);

const char *wickra_wedge_name(struct Wedge *handle);

void wickra_wedge_reset(struct Wedge *handle);

void wickra_wedge_free(struct Wedge *handle);

struct WeightedClose *wickra_weighted_close_new(void);

double wickra_weighted_close_update(struct WeightedClose *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp);

void wickra_weighted_close_batch(struct WeightedClose *handle,
                                 const double *open,
                                 const double *high,
                                 const double *low,
                                 const double *close,
                                 const double *volume,
                                 const int64_t *timestamp,
                                 double *out,
                                 uintptr_t n);

uintptr_t wickra_weighted_close_warmup_period(struct WeightedClose *handle);

bool wickra_weighted_close_is_ready(struct WeightedClose *handle);

const char *wickra_weighted_close_name(struct WeightedClose *handle);

void wickra_weighted_close_reset(struct WeightedClose *handle);

void wickra_weighted_close_free(struct WeightedClose *handle);

struct WickRatio *wickra_wick_ratio_new(void);

double wickra_wick_ratio_update(struct WickRatio *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_wick_ratio_batch(struct WickRatio *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_wick_ratio_warmup_period(struct WickRatio *handle);

bool wickra_wick_ratio_is_ready(struct WickRatio *handle);

const char *wickra_wick_ratio_name(struct WickRatio *handle);

void wickra_wick_ratio_reset(struct WickRatio *handle);

void wickra_wick_ratio_free(struct WickRatio *handle);

struct WilliamsR *wickra_williams_r_new(uintptr_t period);

double wickra_williams_r_update(struct WilliamsR *handle,
                                double open,
                                double high,
                                double low,
                                double close,
                                double volume,
                                int64_t timestamp);

void wickra_williams_r_batch(struct WilliamsR *handle,
                             const double *open,
                             const double *high,
                             const double *low,
                             const double *close,
                             const double *volume,
                             const int64_t *timestamp,
                             double *out,
                             uintptr_t n);

uintptr_t wickra_williams_r_warmup_period(struct WilliamsR *handle);

bool wickra_williams_r_is_ready(struct WilliamsR *handle);

const char *wickra_williams_r_name(struct WilliamsR *handle);

void wickra_williams_r_reset(struct WilliamsR *handle);

void wickra_williams_r_free(struct WilliamsR *handle);

struct YangZhangVolatility *wickra_yang_zhang_volatility_new(uintptr_t period,
                                                             uintptr_t trading_periods);

double wickra_yang_zhang_volatility_update(struct YangZhangVolatility *handle,
                                           double open,
                                           double high,
                                           double low,
                                           double close,
                                           double volume,
                                           int64_t timestamp);

void wickra_yang_zhang_volatility_batch(struct YangZhangVolatility *handle,
                                        const double *open,
                                        const double *high,
                                        const double *low,
                                        const double *close,
                                        const double *volume,
                                        const int64_t *timestamp,
                                        double *out,
                                        uintptr_t n);

uintptr_t wickra_yang_zhang_volatility_warmup_period(struct YangZhangVolatility *handle);

bool wickra_yang_zhang_volatility_is_ready(struct YangZhangVolatility *handle);

const char *wickra_yang_zhang_volatility_name(struct YangZhangVolatility *handle);

void wickra_yang_zhang_volatility_reset(struct YangZhangVolatility *handle);

void wickra_yang_zhang_volatility_free(struct YangZhangVolatility *handle);

struct YoyoExit *wickra_yoyo_exit_new(uintptr_t atr_period, double multiplier);

double wickra_yoyo_exit_update(struct YoyoExit *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp);

void wickra_yoyo_exit_batch(struct YoyoExit *handle,
                            const double *open,
                            const double *high,
                            const double *low,
                            const double *close,
                            const double *volume,
                            const int64_t *timestamp,
                            double *out,
                            uintptr_t n);

uintptr_t wickra_yoyo_exit_warmup_period(struct YoyoExit *handle);

bool wickra_yoyo_exit_is_ready(struct YoyoExit *handle);

const char *wickra_yoyo_exit_name(struct YoyoExit *handle);

void wickra_yoyo_exit_reset(struct YoyoExit *handle);

void wickra_yoyo_exit_free(struct YoyoExit *handle);

struct AmihudIlliquidity *wickra_amihud_illiquidity_new(uintptr_t period);

double wickra_amihud_illiquidity_update(struct AmihudIlliquidity *handle,
                                        double price,
                                        double size,
                                        bool is_buy,
                                        int64_t timestamp);

uintptr_t wickra_amihud_illiquidity_warmup_period(struct AmihudIlliquidity *handle);

bool wickra_amihud_illiquidity_is_ready(struct AmihudIlliquidity *handle);

const char *wickra_amihud_illiquidity_name(struct AmihudIlliquidity *handle);

void wickra_amihud_illiquidity_reset(struct AmihudIlliquidity *handle);

void wickra_amihud_illiquidity_free(struct AmihudIlliquidity *handle);

struct CumulativeVolumeDelta *wickra_cumulative_volume_delta_new(void);

double wickra_cumulative_volume_delta_update(struct CumulativeVolumeDelta *handle,
                                             double price,
                                             double size,
                                             bool is_buy,
                                             int64_t timestamp);

uintptr_t wickra_cumulative_volume_delta_warmup_period(struct CumulativeVolumeDelta *handle);

bool wickra_cumulative_volume_delta_is_ready(struct CumulativeVolumeDelta *handle);

const char *wickra_cumulative_volume_delta_name(struct CumulativeVolumeDelta *handle);

void wickra_cumulative_volume_delta_reset(struct CumulativeVolumeDelta *handle);

void wickra_cumulative_volume_delta_free(struct CumulativeVolumeDelta *handle);

struct Pin *wickra_pin_new(uintptr_t window);

double wickra_pin_update(struct Pin *handle,
                         double price,
                         double size,
                         bool is_buy,
                         int64_t timestamp);

uintptr_t wickra_pin_warmup_period(struct Pin *handle);

bool wickra_pin_is_ready(struct Pin *handle);

const char *wickra_pin_name(struct Pin *handle);

void wickra_pin_reset(struct Pin *handle);

void wickra_pin_free(struct Pin *handle);

struct RollMeasure *wickra_roll_measure_new(uintptr_t period);

double wickra_roll_measure_update(struct RollMeasure *handle,
                                  double price,
                                  double size,
                                  bool is_buy,
                                  int64_t timestamp);

uintptr_t wickra_roll_measure_warmup_period(struct RollMeasure *handle);

bool wickra_roll_measure_is_ready(struct RollMeasure *handle);

const char *wickra_roll_measure_name(struct RollMeasure *handle);

void wickra_roll_measure_reset(struct RollMeasure *handle);

void wickra_roll_measure_free(struct RollMeasure *handle);

struct SignedVolume *wickra_signed_volume_new(void);

double wickra_signed_volume_update(struct SignedVolume *handle,
                                   double price,
                                   double size,
                                   bool is_buy,
                                   int64_t timestamp);

uintptr_t wickra_signed_volume_warmup_period(struct SignedVolume *handle);

bool wickra_signed_volume_is_ready(struct SignedVolume *handle);

const char *wickra_signed_volume_name(struct SignedVolume *handle);

void wickra_signed_volume_reset(struct SignedVolume *handle);

void wickra_signed_volume_free(struct SignedVolume *handle);

struct TradeImbalance *wickra_trade_imbalance_new(uintptr_t window);

double wickra_trade_imbalance_update(struct TradeImbalance *handle,
                                     double price,
                                     double size,
                                     bool is_buy,
                                     int64_t timestamp);

uintptr_t wickra_trade_imbalance_warmup_period(struct TradeImbalance *handle);

bool wickra_trade_imbalance_is_ready(struct TradeImbalance *handle);

const char *wickra_trade_imbalance_name(struct TradeImbalance *handle);

void wickra_trade_imbalance_reset(struct TradeImbalance *handle);

void wickra_trade_imbalance_free(struct TradeImbalance *handle);

struct TradeSignAutocorrelation *wickra_trade_sign_autocorrelation_new(uintptr_t period);

double wickra_trade_sign_autocorrelation_update(struct TradeSignAutocorrelation *handle,
                                                double price,
                                                double size,
                                                bool is_buy,
                                                int64_t timestamp);

uintptr_t wickra_trade_sign_autocorrelation_warmup_period(struct TradeSignAutocorrelation *handle);

bool wickra_trade_sign_autocorrelation_is_ready(struct TradeSignAutocorrelation *handle);

const char *wickra_trade_sign_autocorrelation_name(struct TradeSignAutocorrelation *handle);

void wickra_trade_sign_autocorrelation_reset(struct TradeSignAutocorrelation *handle);

void wickra_trade_sign_autocorrelation_free(struct TradeSignAutocorrelation *handle);

struct Vpin *wickra_vpin_new(double bucket_volume, uintptr_t num_buckets);

double wickra_vpin_update(struct Vpin *handle,
                          double price,
                          double size,
                          bool is_buy,
                          int64_t timestamp);

uintptr_t wickra_vpin_warmup_period(struct Vpin *handle);

bool wickra_vpin_is_ready(struct Vpin *handle);

const char *wickra_vpin_name(struct Vpin *handle);

void wickra_vpin_reset(struct Vpin *handle);

void wickra_vpin_free(struct Vpin *handle);

struct EffectiveSpread *wickra_effective_spread_new(void);

double wickra_effective_spread_update(struct EffectiveSpread *handle,
                                      double price,
                                      double size,
                                      bool is_buy,
                                      int64_t timestamp,
                                      double mid);

uintptr_t wickra_effective_spread_warmup_period(struct EffectiveSpread *handle);

bool wickra_effective_spread_is_ready(struct EffectiveSpread *handle);

const char *wickra_effective_spread_name(struct EffectiveSpread *handle);

void wickra_effective_spread_reset(struct EffectiveSpread *handle);

void wickra_effective_spread_free(struct EffectiveSpread *handle);

struct KylesLambda *wickra_kyles_lambda_new(uintptr_t window);

double wickra_kyles_lambda_update(struct KylesLambda *handle,
                                  double price,
                                  double size,
                                  bool is_buy,
                                  int64_t timestamp,
                                  double mid);

uintptr_t wickra_kyles_lambda_warmup_period(struct KylesLambda *handle);

bool wickra_kyles_lambda_is_ready(struct KylesLambda *handle);

const char *wickra_kyles_lambda_name(struct KylesLambda *handle);

void wickra_kyles_lambda_reset(struct KylesLambda *handle);

void wickra_kyles_lambda_free(struct KylesLambda *handle);

struct RealizedSpread *wickra_realized_spread_new(uintptr_t horizon);

double wickra_realized_spread_update(struct RealizedSpread *handle,
                                     double price,
                                     double size,
                                     bool is_buy,
                                     int64_t timestamp,
                                     double mid);

uintptr_t wickra_realized_spread_warmup_period(struct RealizedSpread *handle);

bool wickra_realized_spread_is_ready(struct RealizedSpread *handle);

const char *wickra_realized_spread_name(struct RealizedSpread *handle);

void wickra_realized_spread_reset(struct RealizedSpread *handle);

void wickra_realized_spread_free(struct RealizedSpread *handle);

struct CalendarSpread *wickra_calendar_spread_new(void);

double wickra_calendar_spread_update(struct CalendarSpread *handle,
                                     double funding_rate,
                                     double mark_price,
                                     double index_price,
                                     double futures_price,
                                     double open_interest,
                                     double long_size,
                                     double short_size,
                                     double taker_buy_volume,
                                     double taker_sell_volume,
                                     double long_liquidation,
                                     double short_liquidation,
                                     int64_t timestamp);

uintptr_t wickra_calendar_spread_warmup_period(struct CalendarSpread *handle);

bool wickra_calendar_spread_is_ready(struct CalendarSpread *handle);

const char *wickra_calendar_spread_name(struct CalendarSpread *handle);

void wickra_calendar_spread_reset(struct CalendarSpread *handle);

void wickra_calendar_spread_free(struct CalendarSpread *handle);

struct EstimatedLeverageRatio *wickra_estimated_leverage_ratio_new(void);

double wickra_estimated_leverage_ratio_update(struct EstimatedLeverageRatio *handle,
                                              double funding_rate,
                                              double mark_price,
                                              double index_price,
                                              double futures_price,
                                              double open_interest,
                                              double long_size,
                                              double short_size,
                                              double taker_buy_volume,
                                              double taker_sell_volume,
                                              double long_liquidation,
                                              double short_liquidation,
                                              int64_t timestamp);

uintptr_t wickra_estimated_leverage_ratio_warmup_period(struct EstimatedLeverageRatio *handle);

bool wickra_estimated_leverage_ratio_is_ready(struct EstimatedLeverageRatio *handle);

const char *wickra_estimated_leverage_ratio_name(struct EstimatedLeverageRatio *handle);

void wickra_estimated_leverage_ratio_reset(struct EstimatedLeverageRatio *handle);

void wickra_estimated_leverage_ratio_free(struct EstimatedLeverageRatio *handle);

struct FundingBasis *wickra_funding_basis_new(void);

double wickra_funding_basis_update(struct FundingBasis *handle,
                                   double funding_rate,
                                   double mark_price,
                                   double index_price,
                                   double futures_price,
                                   double open_interest,
                                   double long_size,
                                   double short_size,
                                   double taker_buy_volume,
                                   double taker_sell_volume,
                                   double long_liquidation,
                                   double short_liquidation,
                                   int64_t timestamp);

uintptr_t wickra_funding_basis_warmup_period(struct FundingBasis *handle);

bool wickra_funding_basis_is_ready(struct FundingBasis *handle);

const char *wickra_funding_basis_name(struct FundingBasis *handle);

void wickra_funding_basis_reset(struct FundingBasis *handle);

void wickra_funding_basis_free(struct FundingBasis *handle);

struct FundingImpliedApr *wickra_funding_implied_apr_new(double intervals_per_year);

double wickra_funding_implied_apr_update(struct FundingImpliedApr *handle,
                                         double funding_rate,
                                         double mark_price,
                                         double index_price,
                                         double futures_price,
                                         double open_interest,
                                         double long_size,
                                         double short_size,
                                         double taker_buy_volume,
                                         double taker_sell_volume,
                                         double long_liquidation,
                                         double short_liquidation,
                                         int64_t timestamp);

uintptr_t wickra_funding_implied_apr_warmup_period(struct FundingImpliedApr *handle);

bool wickra_funding_implied_apr_is_ready(struct FundingImpliedApr *handle);

const char *wickra_funding_implied_apr_name(struct FundingImpliedApr *handle);

void wickra_funding_implied_apr_reset(struct FundingImpliedApr *handle);

void wickra_funding_implied_apr_free(struct FundingImpliedApr *handle);

struct FundingRate *wickra_funding_rate_new(void);

double wickra_funding_rate_update(struct FundingRate *handle,
                                  double funding_rate,
                                  double mark_price,
                                  double index_price,
                                  double futures_price,
                                  double open_interest,
                                  double long_size,
                                  double short_size,
                                  double taker_buy_volume,
                                  double taker_sell_volume,
                                  double long_liquidation,
                                  double short_liquidation,
                                  int64_t timestamp);

uintptr_t wickra_funding_rate_warmup_period(struct FundingRate *handle);

bool wickra_funding_rate_is_ready(struct FundingRate *handle);

const char *wickra_funding_rate_name(struct FundingRate *handle);

void wickra_funding_rate_reset(struct FundingRate *handle);

void wickra_funding_rate_free(struct FundingRate *handle);

struct FundingRateMean *wickra_funding_rate_mean_new(uintptr_t window);

double wickra_funding_rate_mean_update(struct FundingRateMean *handle,
                                       double funding_rate,
                                       double mark_price,
                                       double index_price,
                                       double futures_price,
                                       double open_interest,
                                       double long_size,
                                       double short_size,
                                       double taker_buy_volume,
                                       double taker_sell_volume,
                                       double long_liquidation,
                                       double short_liquidation,
                                       int64_t timestamp);

uintptr_t wickra_funding_rate_mean_warmup_period(struct FundingRateMean *handle);

bool wickra_funding_rate_mean_is_ready(struct FundingRateMean *handle);

const char *wickra_funding_rate_mean_name(struct FundingRateMean *handle);

void wickra_funding_rate_mean_reset(struct FundingRateMean *handle);

void wickra_funding_rate_mean_free(struct FundingRateMean *handle);

struct FundingRateZScore *wickra_funding_rate_z_score_new(uintptr_t window);

double wickra_funding_rate_z_score_update(struct FundingRateZScore *handle,
                                          double funding_rate,
                                          double mark_price,
                                          double index_price,
                                          double futures_price,
                                          double open_interest,
                                          double long_size,
                                          double short_size,
                                          double taker_buy_volume,
                                          double taker_sell_volume,
                                          double long_liquidation,
                                          double short_liquidation,
                                          int64_t timestamp);

uintptr_t wickra_funding_rate_z_score_warmup_period(struct FundingRateZScore *handle);

bool wickra_funding_rate_z_score_is_ready(struct FundingRateZScore *handle);

const char *wickra_funding_rate_z_score_name(struct FundingRateZScore *handle);

void wickra_funding_rate_z_score_reset(struct FundingRateZScore *handle);

void wickra_funding_rate_z_score_free(struct FundingRateZScore *handle);

struct LongShortRatio *wickra_long_short_ratio_new(void);

double wickra_long_short_ratio_update(struct LongShortRatio *handle,
                                      double funding_rate,
                                      double mark_price,
                                      double index_price,
                                      double futures_price,
                                      double open_interest,
                                      double long_size,
                                      double short_size,
                                      double taker_buy_volume,
                                      double taker_sell_volume,
                                      double long_liquidation,
                                      double short_liquidation,
                                      int64_t timestamp);

uintptr_t wickra_long_short_ratio_warmup_period(struct LongShortRatio *handle);

bool wickra_long_short_ratio_is_ready(struct LongShortRatio *handle);

const char *wickra_long_short_ratio_name(struct LongShortRatio *handle);

void wickra_long_short_ratio_reset(struct LongShortRatio *handle);

void wickra_long_short_ratio_free(struct LongShortRatio *handle);

struct OpenInterestDelta *wickra_open_interest_delta_new(void);

double wickra_open_interest_delta_update(struct OpenInterestDelta *handle,
                                         double funding_rate,
                                         double mark_price,
                                         double index_price,
                                         double futures_price,
                                         double open_interest,
                                         double long_size,
                                         double short_size,
                                         double taker_buy_volume,
                                         double taker_sell_volume,
                                         double long_liquidation,
                                         double short_liquidation,
                                         int64_t timestamp);

uintptr_t wickra_open_interest_delta_warmup_period(struct OpenInterestDelta *handle);

bool wickra_open_interest_delta_is_ready(struct OpenInterestDelta *handle);

const char *wickra_open_interest_delta_name(struct OpenInterestDelta *handle);

void wickra_open_interest_delta_reset(struct OpenInterestDelta *handle);

void wickra_open_interest_delta_free(struct OpenInterestDelta *handle);

struct OIPriceDivergence *wickra_oi_price_divergence_new(uintptr_t window);

double wickra_oi_price_divergence_update(struct OIPriceDivergence *handle,
                                         double funding_rate,
                                         double mark_price,
                                         double index_price,
                                         double futures_price,
                                         double open_interest,
                                         double long_size,
                                         double short_size,
                                         double taker_buy_volume,
                                         double taker_sell_volume,
                                         double long_liquidation,
                                         double short_liquidation,
                                         int64_t timestamp);

uintptr_t wickra_oi_price_divergence_warmup_period(struct OIPriceDivergence *handle);

bool wickra_oi_price_divergence_is_ready(struct OIPriceDivergence *handle);

const char *wickra_oi_price_divergence_name(struct OIPriceDivergence *handle);

void wickra_oi_price_divergence_reset(struct OIPriceDivergence *handle);

void wickra_oi_price_divergence_free(struct OIPriceDivergence *handle);

struct OiToVolumeRatio *wickra_oi_to_volume_ratio_new(void);

double wickra_oi_to_volume_ratio_update(struct OiToVolumeRatio *handle,
                                        double funding_rate,
                                        double mark_price,
                                        double index_price,
                                        double futures_price,
                                        double open_interest,
                                        double long_size,
                                        double short_size,
                                        double taker_buy_volume,
                                        double taker_sell_volume,
                                        double long_liquidation,
                                        double short_liquidation,
                                        int64_t timestamp);

uintptr_t wickra_oi_to_volume_ratio_warmup_period(struct OiToVolumeRatio *handle);

bool wickra_oi_to_volume_ratio_is_ready(struct OiToVolumeRatio *handle);

const char *wickra_oi_to_volume_ratio_name(struct OiToVolumeRatio *handle);

void wickra_oi_to_volume_ratio_reset(struct OiToVolumeRatio *handle);

void wickra_oi_to_volume_ratio_free(struct OiToVolumeRatio *handle);

struct OIWeighted *wickra_oi_weighted_new(void);

double wickra_oi_weighted_update(struct OIWeighted *handle,
                                 double funding_rate,
                                 double mark_price,
                                 double index_price,
                                 double futures_price,
                                 double open_interest,
                                 double long_size,
                                 double short_size,
                                 double taker_buy_volume,
                                 double taker_sell_volume,
                                 double long_liquidation,
                                 double short_liquidation,
                                 int64_t timestamp);

uintptr_t wickra_oi_weighted_warmup_period(struct OIWeighted *handle);

bool wickra_oi_weighted_is_ready(struct OIWeighted *handle);

const char *wickra_oi_weighted_name(struct OIWeighted *handle);

void wickra_oi_weighted_reset(struct OIWeighted *handle);

void wickra_oi_weighted_free(struct OIWeighted *handle);

struct OpenInterestMomentum *wickra_open_interest_momentum_new(uintptr_t period);

double wickra_open_interest_momentum_update(struct OpenInterestMomentum *handle,
                                            double funding_rate,
                                            double mark_price,
                                            double index_price,
                                            double futures_price,
                                            double open_interest,
                                            double long_size,
                                            double short_size,
                                            double taker_buy_volume,
                                            double taker_sell_volume,
                                            double long_liquidation,
                                            double short_liquidation,
                                            int64_t timestamp);

uintptr_t wickra_open_interest_momentum_warmup_period(struct OpenInterestMomentum *handle);

bool wickra_open_interest_momentum_is_ready(struct OpenInterestMomentum *handle);

const char *wickra_open_interest_momentum_name(struct OpenInterestMomentum *handle);

void wickra_open_interest_momentum_reset(struct OpenInterestMomentum *handle);

void wickra_open_interest_momentum_free(struct OpenInterestMomentum *handle);

struct PerpetualPremiumIndex *wickra_perpetual_premium_index_new(void);

double wickra_perpetual_premium_index_update(struct PerpetualPremiumIndex *handle,
                                             double funding_rate,
                                             double mark_price,
                                             double index_price,
                                             double futures_price,
                                             double open_interest,
                                             double long_size,
                                             double short_size,
                                             double taker_buy_volume,
                                             double taker_sell_volume,
                                             double long_liquidation,
                                             double short_liquidation,
                                             int64_t timestamp);

uintptr_t wickra_perpetual_premium_index_warmup_period(struct PerpetualPremiumIndex *handle);

bool wickra_perpetual_premium_index_is_ready(struct PerpetualPremiumIndex *handle);

const char *wickra_perpetual_premium_index_name(struct PerpetualPremiumIndex *handle);

void wickra_perpetual_premium_index_reset(struct PerpetualPremiumIndex *handle);

void wickra_perpetual_premium_index_free(struct PerpetualPremiumIndex *handle);

struct TakerBuySellRatio *wickra_taker_buy_sell_ratio_new(void);

double wickra_taker_buy_sell_ratio_update(struct TakerBuySellRatio *handle,
                                          double funding_rate,
                                          double mark_price,
                                          double index_price,
                                          double futures_price,
                                          double open_interest,
                                          double long_size,
                                          double short_size,
                                          double taker_buy_volume,
                                          double taker_sell_volume,
                                          double long_liquidation,
                                          double short_liquidation,
                                          int64_t timestamp);

uintptr_t wickra_taker_buy_sell_ratio_warmup_period(struct TakerBuySellRatio *handle);

bool wickra_taker_buy_sell_ratio_is_ready(struct TakerBuySellRatio *handle);

const char *wickra_taker_buy_sell_ratio_name(struct TakerBuySellRatio *handle);

void wickra_taker_buy_sell_ratio_reset(struct TakerBuySellRatio *handle);

void wickra_taker_buy_sell_ratio_free(struct TakerBuySellRatio *handle);

struct TermStructureBasis *wickra_term_structure_basis_new(void);

double wickra_term_structure_basis_update(struct TermStructureBasis *handle,
                                          double funding_rate,
                                          double mark_price,
                                          double index_price,
                                          double futures_price,
                                          double open_interest,
                                          double long_size,
                                          double short_size,
                                          double taker_buy_volume,
                                          double taker_sell_volume,
                                          double long_liquidation,
                                          double short_liquidation,
                                          int64_t timestamp);

uintptr_t wickra_term_structure_basis_warmup_period(struct TermStructureBasis *handle);

bool wickra_term_structure_basis_is_ready(struct TermStructureBasis *handle);

const char *wickra_term_structure_basis_name(struct TermStructureBasis *handle);

void wickra_term_structure_basis_reset(struct TermStructureBasis *handle);

void wickra_term_structure_basis_free(struct TermStructureBasis *handle);

struct DepthSlope *wickra_depth_slope_new(void);

double wickra_depth_slope_update(struct DepthSlope *handle,
                                 const double *bid_price,
                                 const double *bid_size,
                                 uintptr_t n_bids,
                                 const double *ask_price,
                                 const double *ask_size,
                                 uintptr_t n_asks);

uintptr_t wickra_depth_slope_warmup_period(struct DepthSlope *handle);

bool wickra_depth_slope_is_ready(struct DepthSlope *handle);

const char *wickra_depth_slope_name(struct DepthSlope *handle);

void wickra_depth_slope_reset(struct DepthSlope *handle);

void wickra_depth_slope_free(struct DepthSlope *handle);

struct Microprice *wickra_microprice_new(void);

double wickra_microprice_update(struct Microprice *handle,
                                const double *bid_price,
                                const double *bid_size,
                                uintptr_t n_bids,
                                const double *ask_price,
                                const double *ask_size,
                                uintptr_t n_asks);

uintptr_t wickra_microprice_warmup_period(struct Microprice *handle);

bool wickra_microprice_is_ready(struct Microprice *handle);

const char *wickra_microprice_name(struct Microprice *handle);

void wickra_microprice_reset(struct Microprice *handle);

void wickra_microprice_free(struct Microprice *handle);

struct OrderBookImbalanceFull *wickra_order_book_imbalance_full_new(void);

double wickra_order_book_imbalance_full_update(struct OrderBookImbalanceFull *handle,
                                               const double *bid_price,
                                               const double *bid_size,
                                               uintptr_t n_bids,
                                               const double *ask_price,
                                               const double *ask_size,
                                               uintptr_t n_asks);

uintptr_t wickra_order_book_imbalance_full_warmup_period(struct OrderBookImbalanceFull *handle);

bool wickra_order_book_imbalance_full_is_ready(struct OrderBookImbalanceFull *handle);

const char *wickra_order_book_imbalance_full_name(struct OrderBookImbalanceFull *handle);

void wickra_order_book_imbalance_full_reset(struct OrderBookImbalanceFull *handle);

void wickra_order_book_imbalance_full_free(struct OrderBookImbalanceFull *handle);

struct OrderBookImbalanceTop1 *wickra_order_book_imbalance_top1_new(void);

double wickra_order_book_imbalance_top1_update(struct OrderBookImbalanceTop1 *handle,
                                               const double *bid_price,
                                               const double *bid_size,
                                               uintptr_t n_bids,
                                               const double *ask_price,
                                               const double *ask_size,
                                               uintptr_t n_asks);

uintptr_t wickra_order_book_imbalance_top1_warmup_period(struct OrderBookImbalanceTop1 *handle);

bool wickra_order_book_imbalance_top1_is_ready(struct OrderBookImbalanceTop1 *handle);

const char *wickra_order_book_imbalance_top1_name(struct OrderBookImbalanceTop1 *handle);

void wickra_order_book_imbalance_top1_reset(struct OrderBookImbalanceTop1 *handle);

void wickra_order_book_imbalance_top1_free(struct OrderBookImbalanceTop1 *handle);

struct OrderBookImbalanceTopN *wickra_order_book_imbalance_top_n_new(uintptr_t levels);

double wickra_order_book_imbalance_top_n_update(struct OrderBookImbalanceTopN *handle,
                                                const double *bid_price,
                                                const double *bid_size,
                                                uintptr_t n_bids,
                                                const double *ask_price,
                                                const double *ask_size,
                                                uintptr_t n_asks);

uintptr_t wickra_order_book_imbalance_top_n_warmup_period(struct OrderBookImbalanceTopN *handle);

bool wickra_order_book_imbalance_top_n_is_ready(struct OrderBookImbalanceTopN *handle);

const char *wickra_order_book_imbalance_top_n_name(struct OrderBookImbalanceTopN *handle);

void wickra_order_book_imbalance_top_n_reset(struct OrderBookImbalanceTopN *handle);

void wickra_order_book_imbalance_top_n_free(struct OrderBookImbalanceTopN *handle);

struct OrderFlowImbalance *wickra_order_flow_imbalance_new(uintptr_t period);

double wickra_order_flow_imbalance_update(struct OrderFlowImbalance *handle,
                                          const double *bid_price,
                                          const double *bid_size,
                                          uintptr_t n_bids,
                                          const double *ask_price,
                                          const double *ask_size,
                                          uintptr_t n_asks);

uintptr_t wickra_order_flow_imbalance_warmup_period(struct OrderFlowImbalance *handle);

bool wickra_order_flow_imbalance_is_ready(struct OrderFlowImbalance *handle);

const char *wickra_order_flow_imbalance_name(struct OrderFlowImbalance *handle);

void wickra_order_flow_imbalance_reset(struct OrderFlowImbalance *handle);

void wickra_order_flow_imbalance_free(struct OrderFlowImbalance *handle);

struct QuotedSpread *wickra_quoted_spread_new(void);

double wickra_quoted_spread_update(struct QuotedSpread *handle,
                                   const double *bid_price,
                                   const double *bid_size,
                                   uintptr_t n_bids,
                                   const double *ask_price,
                                   const double *ask_size,
                                   uintptr_t n_asks);

uintptr_t wickra_quoted_spread_warmup_period(struct QuotedSpread *handle);

bool wickra_quoted_spread_is_ready(struct QuotedSpread *handle);

const char *wickra_quoted_spread_name(struct QuotedSpread *handle);

void wickra_quoted_spread_reset(struct QuotedSpread *handle);

void wickra_quoted_spread_free(struct QuotedSpread *handle);

struct AbsoluteBreadthIndex *wickra_absolute_breadth_index_new(void);

double wickra_absolute_breadth_index_update(struct AbsoluteBreadthIndex *handle,
                                            const double *change,
                                            const double *volume,
                                            const bool *new_high,
                                            const bool *new_low,
                                            const bool *above_ma,
                                            const bool *on_buy_signal,
                                            uintptr_t n,
                                            int64_t timestamp);

uintptr_t wickra_absolute_breadth_index_warmup_period(struct AbsoluteBreadthIndex *handle);

bool wickra_absolute_breadth_index_is_ready(struct AbsoluteBreadthIndex *handle);

const char *wickra_absolute_breadth_index_name(struct AbsoluteBreadthIndex *handle);

void wickra_absolute_breadth_index_reset(struct AbsoluteBreadthIndex *handle);

void wickra_absolute_breadth_index_free(struct AbsoluteBreadthIndex *handle);

struct AdVolumeLine *wickra_ad_volume_line_new(void);

double wickra_ad_volume_line_update(struct AdVolumeLine *handle,
                                    const double *change,
                                    const double *volume,
                                    const bool *new_high,
                                    const bool *new_low,
                                    const bool *above_ma,
                                    const bool *on_buy_signal,
                                    uintptr_t n,
                                    int64_t timestamp);

uintptr_t wickra_ad_volume_line_warmup_period(struct AdVolumeLine *handle);

bool wickra_ad_volume_line_is_ready(struct AdVolumeLine *handle);

const char *wickra_ad_volume_line_name(struct AdVolumeLine *handle);

void wickra_ad_volume_line_reset(struct AdVolumeLine *handle);

void wickra_ad_volume_line_free(struct AdVolumeLine *handle);

struct AdvanceDecline *wickra_advance_decline_new(void);

double wickra_advance_decline_update(struct AdvanceDecline *handle,
                                     const double *change,
                                     const double *volume,
                                     const bool *new_high,
                                     const bool *new_low,
                                     const bool *above_ma,
                                     const bool *on_buy_signal,
                                     uintptr_t n,
                                     int64_t timestamp);

uintptr_t wickra_advance_decline_warmup_period(struct AdvanceDecline *handle);

bool wickra_advance_decline_is_ready(struct AdvanceDecline *handle);

const char *wickra_advance_decline_name(struct AdvanceDecline *handle);

void wickra_advance_decline_reset(struct AdvanceDecline *handle);

void wickra_advance_decline_free(struct AdvanceDecline *handle);

struct AdvanceDeclineRatio *wickra_advance_decline_ratio_new(void);

double wickra_advance_decline_ratio_update(struct AdvanceDeclineRatio *handle,
                                           const double *change,
                                           const double *volume,
                                           const bool *new_high,
                                           const bool *new_low,
                                           const bool *above_ma,
                                           const bool *on_buy_signal,
                                           uintptr_t n,
                                           int64_t timestamp);

uintptr_t wickra_advance_decline_ratio_warmup_period(struct AdvanceDeclineRatio *handle);

bool wickra_advance_decline_ratio_is_ready(struct AdvanceDeclineRatio *handle);

const char *wickra_advance_decline_ratio_name(struct AdvanceDeclineRatio *handle);

void wickra_advance_decline_ratio_reset(struct AdvanceDeclineRatio *handle);

void wickra_advance_decline_ratio_free(struct AdvanceDeclineRatio *handle);

struct BreadthThrust *wickra_breadth_thrust_new(uintptr_t period);

double wickra_breadth_thrust_update(struct BreadthThrust *handle,
                                    const double *change,
                                    const double *volume,
                                    const bool *new_high,
                                    const bool *new_low,
                                    const bool *above_ma,
                                    const bool *on_buy_signal,
                                    uintptr_t n,
                                    int64_t timestamp);

uintptr_t wickra_breadth_thrust_warmup_period(struct BreadthThrust *handle);

bool wickra_breadth_thrust_is_ready(struct BreadthThrust *handle);

const char *wickra_breadth_thrust_name(struct BreadthThrust *handle);

void wickra_breadth_thrust_reset(struct BreadthThrust *handle);

void wickra_breadth_thrust_free(struct BreadthThrust *handle);

struct BullishPercentIndex *wickra_bullish_percent_index_new(void);

double wickra_bullish_percent_index_update(struct BullishPercentIndex *handle,
                                           const double *change,
                                           const double *volume,
                                           const bool *new_high,
                                           const bool *new_low,
                                           const bool *above_ma,
                                           const bool *on_buy_signal,
                                           uintptr_t n,
                                           int64_t timestamp);

uintptr_t wickra_bullish_percent_index_warmup_period(struct BullishPercentIndex *handle);

bool wickra_bullish_percent_index_is_ready(struct BullishPercentIndex *handle);

const char *wickra_bullish_percent_index_name(struct BullishPercentIndex *handle);

void wickra_bullish_percent_index_reset(struct BullishPercentIndex *handle);

void wickra_bullish_percent_index_free(struct BullishPercentIndex *handle);

struct CumulativeVolumeIndex *wickra_cumulative_volume_index_new(void);

double wickra_cumulative_volume_index_update(struct CumulativeVolumeIndex *handle,
                                             const double *change,
                                             const double *volume,
                                             const bool *new_high,
                                             const bool *new_low,
                                             const bool *above_ma,
                                             const bool *on_buy_signal,
                                             uintptr_t n,
                                             int64_t timestamp);

uintptr_t wickra_cumulative_volume_index_warmup_period(struct CumulativeVolumeIndex *handle);

bool wickra_cumulative_volume_index_is_ready(struct CumulativeVolumeIndex *handle);

const char *wickra_cumulative_volume_index_name(struct CumulativeVolumeIndex *handle);

void wickra_cumulative_volume_index_reset(struct CumulativeVolumeIndex *handle);

void wickra_cumulative_volume_index_free(struct CumulativeVolumeIndex *handle);

struct HighLowIndex *wickra_high_low_index_new(uintptr_t period);

double wickra_high_low_index_update(struct HighLowIndex *handle,
                                    const double *change,
                                    const double *volume,
                                    const bool *new_high,
                                    const bool *new_low,
                                    const bool *above_ma,
                                    const bool *on_buy_signal,
                                    uintptr_t n,
                                    int64_t timestamp);

uintptr_t wickra_high_low_index_warmup_period(struct HighLowIndex *handle);

bool wickra_high_low_index_is_ready(struct HighLowIndex *handle);

const char *wickra_high_low_index_name(struct HighLowIndex *handle);

void wickra_high_low_index_reset(struct HighLowIndex *handle);

void wickra_high_low_index_free(struct HighLowIndex *handle);

struct McClellanOscillator *wickra_mc_clellan_oscillator_new(void);

double wickra_mc_clellan_oscillator_update(struct McClellanOscillator *handle,
                                           const double *change,
                                           const double *volume,
                                           const bool *new_high,
                                           const bool *new_low,
                                           const bool *above_ma,
                                           const bool *on_buy_signal,
                                           uintptr_t n,
                                           int64_t timestamp);

uintptr_t wickra_mc_clellan_oscillator_warmup_period(struct McClellanOscillator *handle);

bool wickra_mc_clellan_oscillator_is_ready(struct McClellanOscillator *handle);

const char *wickra_mc_clellan_oscillator_name(struct McClellanOscillator *handle);

void wickra_mc_clellan_oscillator_reset(struct McClellanOscillator *handle);

void wickra_mc_clellan_oscillator_free(struct McClellanOscillator *handle);

struct McClellanSummationIndex *wickra_mc_clellan_summation_index_new(void);

double wickra_mc_clellan_summation_index_update(struct McClellanSummationIndex *handle,
                                                const double *change,
                                                const double *volume,
                                                const bool *new_high,
                                                const bool *new_low,
                                                const bool *above_ma,
                                                const bool *on_buy_signal,
                                                uintptr_t n,
                                                int64_t timestamp);

uintptr_t wickra_mc_clellan_summation_index_warmup_period(struct McClellanSummationIndex *handle);

bool wickra_mc_clellan_summation_index_is_ready(struct McClellanSummationIndex *handle);

const char *wickra_mc_clellan_summation_index_name(struct McClellanSummationIndex *handle);

void wickra_mc_clellan_summation_index_reset(struct McClellanSummationIndex *handle);

void wickra_mc_clellan_summation_index_free(struct McClellanSummationIndex *handle);

struct NewHighsNewLows *wickra_new_highs_new_lows_new(void);

double wickra_new_highs_new_lows_update(struct NewHighsNewLows *handle,
                                        const double *change,
                                        const double *volume,
                                        const bool *new_high,
                                        const bool *new_low,
                                        const bool *above_ma,
                                        const bool *on_buy_signal,
                                        uintptr_t n,
                                        int64_t timestamp);

uintptr_t wickra_new_highs_new_lows_warmup_period(struct NewHighsNewLows *handle);

bool wickra_new_highs_new_lows_is_ready(struct NewHighsNewLows *handle);

const char *wickra_new_highs_new_lows_name(struct NewHighsNewLows *handle);

void wickra_new_highs_new_lows_reset(struct NewHighsNewLows *handle);

void wickra_new_highs_new_lows_free(struct NewHighsNewLows *handle);

struct PercentAboveMa *wickra_percent_above_ma_new(void);

double wickra_percent_above_ma_update(struct PercentAboveMa *handle,
                                      const double *change,
                                      const double *volume,
                                      const bool *new_high,
                                      const bool *new_low,
                                      const bool *above_ma,
                                      const bool *on_buy_signal,
                                      uintptr_t n,
                                      int64_t timestamp);

uintptr_t wickra_percent_above_ma_warmup_period(struct PercentAboveMa *handle);

bool wickra_percent_above_ma_is_ready(struct PercentAboveMa *handle);

const char *wickra_percent_above_ma_name(struct PercentAboveMa *handle);

void wickra_percent_above_ma_reset(struct PercentAboveMa *handle);

void wickra_percent_above_ma_free(struct PercentAboveMa *handle);

struct TickIndex *wickra_tick_index_new(void);

double wickra_tick_index_update(struct TickIndex *handle,
                                const double *change,
                                const double *volume,
                                const bool *new_high,
                                const bool *new_low,
                                const bool *above_ma,
                                const bool *on_buy_signal,
                                uintptr_t n,
                                int64_t timestamp);

uintptr_t wickra_tick_index_warmup_period(struct TickIndex *handle);

bool wickra_tick_index_is_ready(struct TickIndex *handle);

const char *wickra_tick_index_name(struct TickIndex *handle);

void wickra_tick_index_reset(struct TickIndex *handle);

void wickra_tick_index_free(struct TickIndex *handle);

struct Trin *wickra_trin_new(void);

double wickra_trin_update(struct Trin *handle,
                          const double *change,
                          const double *volume,
                          const bool *new_high,
                          const bool *new_low,
                          const bool *above_ma,
                          const bool *on_buy_signal,
                          uintptr_t n,
                          int64_t timestamp);

uintptr_t wickra_trin_warmup_period(struct Trin *handle);

bool wickra_trin_is_ready(struct Trin *handle);

const char *wickra_trin_name(struct Trin *handle);

void wickra_trin_reset(struct Trin *handle);

void wickra_trin_free(struct Trin *handle);

struct UpDownVolumeRatio *wickra_up_down_volume_ratio_new(void);

double wickra_up_down_volume_ratio_update(struct UpDownVolumeRatio *handle,
                                          const double *change,
                                          const double *volume,
                                          const bool *new_high,
                                          const bool *new_low,
                                          const bool *above_ma,
                                          const bool *on_buy_signal,
                                          uintptr_t n,
                                          int64_t timestamp);

uintptr_t wickra_up_down_volume_ratio_warmup_period(struct UpDownVolumeRatio *handle);

bool wickra_up_down_volume_ratio_is_ready(struct UpDownVolumeRatio *handle);

const char *wickra_up_down_volume_ratio_name(struct UpDownVolumeRatio *handle);

void wickra_up_down_volume_ratio_reset(struct UpDownVolumeRatio *handle);

void wickra_up_down_volume_ratio_free(struct UpDownVolumeRatio *handle);

struct AccelerationBands *wickra_acceleration_bands_new(uintptr_t period, double factor);

bool wickra_acceleration_bands_update(struct AccelerationBands *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp,
                                      struct WickraAccelerationBandsOutput *out);

uintptr_t wickra_acceleration_bands_warmup_period(struct AccelerationBands *handle);

bool wickra_acceleration_bands_is_ready(struct AccelerationBands *handle);

const char *wickra_acceleration_bands_name(struct AccelerationBands *handle);

void wickra_acceleration_bands_reset(struct AccelerationBands *handle);

void wickra_acceleration_bands_free(struct AccelerationBands *handle);

struct Adx *wickra_adx_new(uintptr_t period);

bool wickra_adx_update(struct Adx *handle,
                       double open,
                       double high,
                       double low,
                       double close,
                       double volume,
                       int64_t timestamp,
                       struct WickraAdxOutput *out);

uintptr_t wickra_adx_warmup_period(struct Adx *handle);

bool wickra_adx_is_ready(struct Adx *handle);

const char *wickra_adx_name(struct Adx *handle);

void wickra_adx_reset(struct Adx *handle);

void wickra_adx_free(struct Adx *handle);

struct Alligator *wickra_alligator_new(uintptr_t jaw_period,
                                       uintptr_t teeth_period,
                                       uintptr_t lips_period);

bool wickra_alligator_update(struct Alligator *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp,
                             struct WickraAlligatorOutput *out);

uintptr_t wickra_alligator_warmup_period(struct Alligator *handle);

bool wickra_alligator_is_ready(struct Alligator *handle);

const char *wickra_alligator_name(struct Alligator *handle);

void wickra_alligator_reset(struct Alligator *handle);

void wickra_alligator_free(struct Alligator *handle);

struct AndrewsPitchfork *wickra_andrews_pitchfork_new(uintptr_t strength);

bool wickra_andrews_pitchfork_update(struct AndrewsPitchfork *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp,
                                     struct WickraAndrewsPitchforkOutput *out);

uintptr_t wickra_andrews_pitchfork_warmup_period(struct AndrewsPitchfork *handle);

bool wickra_andrews_pitchfork_is_ready(struct AndrewsPitchfork *handle);

const char *wickra_andrews_pitchfork_name(struct AndrewsPitchfork *handle);

void wickra_andrews_pitchfork_reset(struct AndrewsPitchfork *handle);

void wickra_andrews_pitchfork_free(struct AndrewsPitchfork *handle);

struct Aroon *wickra_aroon_new(uintptr_t period);

bool wickra_aroon_update(struct Aroon *handle,
                         double open,
                         double high,
                         double low,
                         double close,
                         double volume,
                         int64_t timestamp,
                         struct WickraAroonOutput *out);

uintptr_t wickra_aroon_warmup_period(struct Aroon *handle);

bool wickra_aroon_is_ready(struct Aroon *handle);

const char *wickra_aroon_name(struct Aroon *handle);

void wickra_aroon_reset(struct Aroon *handle);

void wickra_aroon_free(struct Aroon *handle);

struct AtrBands *wickra_atr_bands_new(uintptr_t period, double multiplier);

bool wickra_atr_bands_update(struct AtrBands *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp,
                             struct WickraAtrBandsOutput *out);

uintptr_t wickra_atr_bands_warmup_period(struct AtrBands *handle);

bool wickra_atr_bands_is_ready(struct AtrBands *handle);

const char *wickra_atr_bands_name(struct AtrBands *handle);

void wickra_atr_bands_reset(struct AtrBands *handle);

void wickra_atr_bands_free(struct AtrBands *handle);

struct AtrRatchet *wickra_atr_ratchet_new(uintptr_t atr_period,
                                          double start_mult,
                                          double increment);

bool wickra_atr_ratchet_update(struct AtrRatchet *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp,
                               struct WickraAtrRatchetOutput *out);

uintptr_t wickra_atr_ratchet_warmup_period(struct AtrRatchet *handle);

bool wickra_atr_ratchet_is_ready(struct AtrRatchet *handle);

const char *wickra_atr_ratchet_name(struct AtrRatchet *handle);

void wickra_atr_ratchet_reset(struct AtrRatchet *handle);

void wickra_atr_ratchet_free(struct AtrRatchet *handle);

struct AutoFib *wickra_auto_fib_new(void);

bool wickra_auto_fib_update(struct AutoFib *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp,
                            struct WickraAutoFibOutput *out);

uintptr_t wickra_auto_fib_warmup_period(struct AutoFib *handle);

bool wickra_auto_fib_is_ready(struct AutoFib *handle);

const char *wickra_auto_fib_name(struct AutoFib *handle);

void wickra_auto_fib_reset(struct AutoFib *handle);

void wickra_auto_fib_free(struct AutoFib *handle);

struct BollingerBands *wickra_bollinger_bands_new(uintptr_t period, double multiplier);

bool wickra_bollinger_bands_update(struct BollingerBands *handle,
                                   double value,
                                   struct WickraBollingerOutput *out);

uintptr_t wickra_bollinger_bands_warmup_period(struct BollingerBands *handle);

bool wickra_bollinger_bands_is_ready(struct BollingerBands *handle);

const char *wickra_bollinger_bands_name(struct BollingerBands *handle);

void wickra_bollinger_bands_reset(struct BollingerBands *handle);

void wickra_bollinger_bands_free(struct BollingerBands *handle);

struct BomarBands *wickra_bomar_bands_new(uintptr_t period, double coverage);

bool wickra_bomar_bands_update(struct BomarBands *handle,
                               double value,
                               struct WickraBomarBandsOutput *out);

uintptr_t wickra_bomar_bands_warmup_period(struct BomarBands *handle);

bool wickra_bomar_bands_is_ready(struct BomarBands *handle);

const char *wickra_bomar_bands_name(struct BomarBands *handle);

void wickra_bomar_bands_reset(struct BomarBands *handle);

void wickra_bomar_bands_free(struct BomarBands *handle);

struct Camarilla *wickra_camarilla_new(void);

bool wickra_camarilla_update(struct Camarilla *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp,
                             struct WickraCamarillaPivotsOutput *out);

uintptr_t wickra_camarilla_warmup_period(struct Camarilla *handle);

bool wickra_camarilla_is_ready(struct Camarilla *handle);

const char *wickra_camarilla_name(struct Camarilla *handle);

void wickra_camarilla_reset(struct Camarilla *handle);

void wickra_camarilla_free(struct Camarilla *handle);

struct CandleVolume *wickra_candle_volume_new(uintptr_t period);

bool wickra_candle_volume_update(struct CandleVolume *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraCandleVolumeOutput *out);

uintptr_t wickra_candle_volume_warmup_period(struct CandleVolume *handle);

bool wickra_candle_volume_is_ready(struct CandleVolume *handle);

const char *wickra_candle_volume_name(struct CandleVolume *handle);

void wickra_candle_volume_reset(struct CandleVolume *handle);

void wickra_candle_volume_free(struct CandleVolume *handle);

struct CentralPivotRange *wickra_central_pivot_range_new(void);

bool wickra_central_pivot_range_update(struct CentralPivotRange *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp,
                                       struct WickraCentralPivotRangeOutput *out);

uintptr_t wickra_central_pivot_range_warmup_period(struct CentralPivotRange *handle);

bool wickra_central_pivot_range_is_ready(struct CentralPivotRange *handle);

const char *wickra_central_pivot_range_name(struct CentralPivotRange *handle);

void wickra_central_pivot_range_reset(struct CentralPivotRange *handle);

void wickra_central_pivot_range_free(struct CentralPivotRange *handle);

struct ChandeKrollStop *wickra_chande_kroll_stop_new(uintptr_t atr_period,
                                                     double atr_multiplier,
                                                     uintptr_t stop_period);

bool wickra_chande_kroll_stop_update(struct ChandeKrollStop *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp,
                                     struct WickraChandeKrollStopOutput *out);

uintptr_t wickra_chande_kroll_stop_warmup_period(struct ChandeKrollStop *handle);

bool wickra_chande_kroll_stop_is_ready(struct ChandeKrollStop *handle);

const char *wickra_chande_kroll_stop_name(struct ChandeKrollStop *handle);

void wickra_chande_kroll_stop_reset(struct ChandeKrollStop *handle);

void wickra_chande_kroll_stop_free(struct ChandeKrollStop *handle);

struct ChandelierExit *wickra_chandelier_exit_new(uintptr_t period, double multiplier);

bool wickra_chandelier_exit_update(struct ChandelierExit *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp,
                                   struct WickraChandelierExitOutput *out);

uintptr_t wickra_chandelier_exit_warmup_period(struct ChandelierExit *handle);

bool wickra_chandelier_exit_is_ready(struct ChandelierExit *handle);

const char *wickra_chandelier_exit_name(struct ChandelierExit *handle);

void wickra_chandelier_exit_reset(struct ChandelierExit *handle);

void wickra_chandelier_exit_free(struct ChandelierExit *handle);

struct ClassicPivots *wickra_classic_pivots_new(void);

bool wickra_classic_pivots_update(struct ClassicPivots *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp,
                                  struct WickraClassicPivotsOutput *out);

uintptr_t wickra_classic_pivots_warmup_period(struct ClassicPivots *handle);

bool wickra_classic_pivots_is_ready(struct ClassicPivots *handle);

const char *wickra_classic_pivots_name(struct ClassicPivots *handle);

void wickra_classic_pivots_reset(struct ClassicPivots *handle);

void wickra_classic_pivots_free(struct ClassicPivots *handle);

struct Cointegration *wickra_cointegration_new(uintptr_t period, uintptr_t adf_lags);

bool wickra_cointegration_update(struct Cointegration *handle,
                                 double x,
                                 double y,
                                 struct WickraCointegrationOutput *out);

uintptr_t wickra_cointegration_warmup_period(struct Cointegration *handle);

bool wickra_cointegration_is_ready(struct Cointegration *handle);

const char *wickra_cointegration_name(struct Cointegration *handle);

void wickra_cointegration_reset(struct Cointegration *handle);

void wickra_cointegration_free(struct Cointegration *handle);

struct CompositeProfile *wickra_composite_profile_new(uintptr_t period,
                                                      uintptr_t bins,
                                                      double value_area_pct);

bool wickra_composite_profile_update(struct CompositeProfile *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp,
                                     struct WickraCompositeProfileOutput *out);

uintptr_t wickra_composite_profile_warmup_period(struct CompositeProfile *handle);

bool wickra_composite_profile_is_ready(struct CompositeProfile *handle);

const char *wickra_composite_profile_name(struct CompositeProfile *handle);

void wickra_composite_profile_reset(struct CompositeProfile *handle);

void wickra_composite_profile_free(struct CompositeProfile *handle);

struct DemarkPivots *wickra_demark_pivots_new(void);

bool wickra_demark_pivots_update(struct DemarkPivots *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraDemarkPivotsOutput *out);

uintptr_t wickra_demark_pivots_warmup_period(struct DemarkPivots *handle);

bool wickra_demark_pivots_is_ready(struct DemarkPivots *handle);

const char *wickra_demark_pivots_name(struct DemarkPivots *handle);

void wickra_demark_pivots_reset(struct DemarkPivots *handle);

void wickra_demark_pivots_free(struct DemarkPivots *handle);

struct Donchian *wickra_donchian_new(uintptr_t period);

bool wickra_donchian_update(struct Donchian *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp,
                            struct WickraDonchianOutput *out);

uintptr_t wickra_donchian_warmup_period(struct Donchian *handle);

bool wickra_donchian_is_ready(struct Donchian *handle);

const char *wickra_donchian_name(struct Donchian *handle);

void wickra_donchian_reset(struct Donchian *handle);

void wickra_donchian_free(struct Donchian *handle);

struct DonchianStop *wickra_donchian_stop_new(uintptr_t period);

bool wickra_donchian_stop_update(struct DonchianStop *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraDonchianStopOutput *out);

uintptr_t wickra_donchian_stop_warmup_period(struct DonchianStop *handle);

bool wickra_donchian_stop_is_ready(struct DonchianStop *handle);

const char *wickra_donchian_stop_name(struct DonchianStop *handle);

void wickra_donchian_stop_reset(struct DonchianStop *handle);

void wickra_donchian_stop_free(struct DonchianStop *handle);

struct DoubleBollinger *wickra_double_bollinger_new(uintptr_t period,
                                                    double k_inner,
                                                    double k_outer);

bool wickra_double_bollinger_update(struct DoubleBollinger *handle,
                                    double value,
                                    struct WickraDoubleBollingerOutput *out);

uintptr_t wickra_double_bollinger_warmup_period(struct DoubleBollinger *handle);

bool wickra_double_bollinger_is_ready(struct DoubleBollinger *handle);

const char *wickra_double_bollinger_name(struct DoubleBollinger *handle);

void wickra_double_bollinger_reset(struct DoubleBollinger *handle);

void wickra_double_bollinger_free(struct DoubleBollinger *handle);

struct ElderRay *wickra_elder_ray_new(uintptr_t period);

bool wickra_elder_ray_update(struct ElderRay *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp,
                             struct WickraElderRayOutput *out);

uintptr_t wickra_elder_ray_warmup_period(struct ElderRay *handle);

bool wickra_elder_ray_is_ready(struct ElderRay *handle);

const char *wickra_elder_ray_name(struct ElderRay *handle);

void wickra_elder_ray_reset(struct ElderRay *handle);

void wickra_elder_ray_free(struct ElderRay *handle);

struct ElderSafeZone *wickra_elder_safe_zone_new(uintptr_t period, double coeff);

bool wickra_elder_safe_zone_update(struct ElderSafeZone *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp,
                                   struct WickraElderSafeZoneOutput *out);

uintptr_t wickra_elder_safe_zone_warmup_period(struct ElderSafeZone *handle);

bool wickra_elder_safe_zone_is_ready(struct ElderSafeZone *handle);

const char *wickra_elder_safe_zone_name(struct ElderSafeZone *handle);

void wickra_elder_safe_zone_reset(struct ElderSafeZone *handle);

void wickra_elder_safe_zone_free(struct ElderSafeZone *handle);

struct Equivolume *wickra_equivolume_new(uintptr_t period);

bool wickra_equivolume_update(struct Equivolume *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp,
                              struct WickraEquivolumeOutput *out);

uintptr_t wickra_equivolume_warmup_period(struct Equivolume *handle);

bool wickra_equivolume_is_ready(struct Equivolume *handle);

const char *wickra_equivolume_name(struct Equivolume *handle);

void wickra_equivolume_reset(struct Equivolume *handle);

void wickra_equivolume_free(struct Equivolume *handle);

struct FibArcs *wickra_fib_arcs_new(void);

bool wickra_fib_arcs_update(struct FibArcs *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp,
                            struct WickraFibArcsOutput *out);

uintptr_t wickra_fib_arcs_warmup_period(struct FibArcs *handle);

bool wickra_fib_arcs_is_ready(struct FibArcs *handle);

const char *wickra_fib_arcs_name(struct FibArcs *handle);

void wickra_fib_arcs_reset(struct FibArcs *handle);

void wickra_fib_arcs_free(struct FibArcs *handle);

struct FibChannel *wickra_fib_channel_new(void);

bool wickra_fib_channel_update(struct FibChannel *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp,
                               struct WickraFibChannelOutput *out);

uintptr_t wickra_fib_channel_warmup_period(struct FibChannel *handle);

bool wickra_fib_channel_is_ready(struct FibChannel *handle);

const char *wickra_fib_channel_name(struct FibChannel *handle);

void wickra_fib_channel_reset(struct FibChannel *handle);

void wickra_fib_channel_free(struct FibChannel *handle);

struct FibConfluence *wickra_fib_confluence_new(void);

bool wickra_fib_confluence_update(struct FibConfluence *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp,
                                  struct WickraFibConfluenceOutput *out);

uintptr_t wickra_fib_confluence_warmup_period(struct FibConfluence *handle);

bool wickra_fib_confluence_is_ready(struct FibConfluence *handle);

const char *wickra_fib_confluence_name(struct FibConfluence *handle);

void wickra_fib_confluence_reset(struct FibConfluence *handle);

void wickra_fib_confluence_free(struct FibConfluence *handle);

struct FibExtension *wickra_fib_extension_new(void);

bool wickra_fib_extension_update(struct FibExtension *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraFibExtensionOutput *out);

uintptr_t wickra_fib_extension_warmup_period(struct FibExtension *handle);

bool wickra_fib_extension_is_ready(struct FibExtension *handle);

const char *wickra_fib_extension_name(struct FibExtension *handle);

void wickra_fib_extension_reset(struct FibExtension *handle);

void wickra_fib_extension_free(struct FibExtension *handle);

struct FibFan *wickra_fib_fan_new(void);

bool wickra_fib_fan_update(struct FibFan *handle,
                           double open,
                           double high,
                           double low,
                           double close,
                           double volume,
                           int64_t timestamp,
                           struct WickraFibFanOutput *out);

uintptr_t wickra_fib_fan_warmup_period(struct FibFan *handle);

bool wickra_fib_fan_is_ready(struct FibFan *handle);

const char *wickra_fib_fan_name(struct FibFan *handle);

void wickra_fib_fan_reset(struct FibFan *handle);

void wickra_fib_fan_free(struct FibFan *handle);

struct FibProjection *wickra_fib_projection_new(void);

bool wickra_fib_projection_update(struct FibProjection *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp,
                                  struct WickraFibProjectionOutput *out);

uintptr_t wickra_fib_projection_warmup_period(struct FibProjection *handle);

bool wickra_fib_projection_is_ready(struct FibProjection *handle);

const char *wickra_fib_projection_name(struct FibProjection *handle);

void wickra_fib_projection_reset(struct FibProjection *handle);

void wickra_fib_projection_free(struct FibProjection *handle);

struct FibRetracement *wickra_fib_retracement_new(void);

bool wickra_fib_retracement_update(struct FibRetracement *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp,
                                   struct WickraFibRetracementOutput *out);

uintptr_t wickra_fib_retracement_warmup_period(struct FibRetracement *handle);

bool wickra_fib_retracement_is_ready(struct FibRetracement *handle);

const char *wickra_fib_retracement_name(struct FibRetracement *handle);

void wickra_fib_retracement_reset(struct FibRetracement *handle);

void wickra_fib_retracement_free(struct FibRetracement *handle);

struct FibTimeZones *wickra_fib_time_zones_new(void);

bool wickra_fib_time_zones_update(struct FibTimeZones *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp,
                                  struct WickraFibTimeZonesOutput *out);

uintptr_t wickra_fib_time_zones_warmup_period(struct FibTimeZones *handle);

bool wickra_fib_time_zones_is_ready(struct FibTimeZones *handle);

const char *wickra_fib_time_zones_name(struct FibTimeZones *handle);

void wickra_fib_time_zones_reset(struct FibTimeZones *handle);

void wickra_fib_time_zones_free(struct FibTimeZones *handle);

struct FibonacciPivots *wickra_fibonacci_pivots_new(void);

bool wickra_fibonacci_pivots_update(struct FibonacciPivots *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp,
                                    struct WickraFibonacciPivotsOutput *out);

uintptr_t wickra_fibonacci_pivots_warmup_period(struct FibonacciPivots *handle);

bool wickra_fibonacci_pivots_is_ready(struct FibonacciPivots *handle);

const char *wickra_fibonacci_pivots_name(struct FibonacciPivots *handle);

void wickra_fibonacci_pivots_reset(struct FibonacciPivots *handle);

void wickra_fibonacci_pivots_free(struct FibonacciPivots *handle);

struct FractalChaosBands *wickra_fractal_chaos_bands_new(uintptr_t k);

bool wickra_fractal_chaos_bands_update(struct FractalChaosBands *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp,
                                       struct WickraFractalChaosBandsOutput *out);

uintptr_t wickra_fractal_chaos_bands_warmup_period(struct FractalChaosBands *handle);

bool wickra_fractal_chaos_bands_is_ready(struct FractalChaosBands *handle);

const char *wickra_fractal_chaos_bands_name(struct FractalChaosBands *handle);

void wickra_fractal_chaos_bands_reset(struct FractalChaosBands *handle);

void wickra_fractal_chaos_bands_free(struct FractalChaosBands *handle);

struct GatorOscillator *wickra_gator_oscillator_new(uintptr_t jaw_period,
                                                    uintptr_t teeth_period,
                                                    uintptr_t lips_period);

bool wickra_gator_oscillator_update(struct GatorOscillator *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp,
                                    struct WickraGatorOscillatorOutput *out);

uintptr_t wickra_gator_oscillator_warmup_period(struct GatorOscillator *handle);

bool wickra_gator_oscillator_is_ready(struct GatorOscillator *handle);

const char *wickra_gator_oscillator_name(struct GatorOscillator *handle);

void wickra_gator_oscillator_reset(struct GatorOscillator *handle);

void wickra_gator_oscillator_free(struct GatorOscillator *handle);

struct GoldenPocket *wickra_golden_pocket_new(void);

bool wickra_golden_pocket_update(struct GoldenPocket *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraGoldenPocketOutput *out);

uintptr_t wickra_golden_pocket_warmup_period(struct GoldenPocket *handle);

bool wickra_golden_pocket_is_ready(struct GoldenPocket *handle);

const char *wickra_golden_pocket_name(struct GoldenPocket *handle);

void wickra_golden_pocket_reset(struct GoldenPocket *handle);

void wickra_golden_pocket_free(struct GoldenPocket *handle);

struct HeikinAshi *wickra_heikin_ashi_new(void);

bool wickra_heikin_ashi_update(struct HeikinAshi *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp,
                               struct WickraHeikinAshiOutput *out);

uintptr_t wickra_heikin_ashi_warmup_period(struct HeikinAshi *handle);

bool wickra_heikin_ashi_is_ready(struct HeikinAshi *handle);

const char *wickra_heikin_ashi_name(struct HeikinAshi *handle);

void wickra_heikin_ashi_reset(struct HeikinAshi *handle);

void wickra_heikin_ashi_free(struct HeikinAshi *handle);

struct HighLowVolumeNodes *wickra_high_low_volume_nodes_new(uintptr_t period, uintptr_t bins);

bool wickra_high_low_volume_nodes_update(struct HighLowVolumeNodes *handle,
                                         double open,
                                         double high,
                                         double low,
                                         double close,
                                         double volume,
                                         int64_t timestamp,
                                         struct WickraHighLowVolumeNodesOutput *out);

uintptr_t wickra_high_low_volume_nodes_warmup_period(struct HighLowVolumeNodes *handle);

bool wickra_high_low_volume_nodes_is_ready(struct HighLowVolumeNodes *handle);

const char *wickra_high_low_volume_nodes_name(struct HighLowVolumeNodes *handle);

void wickra_high_low_volume_nodes_reset(struct HighLowVolumeNodes *handle);

void wickra_high_low_volume_nodes_free(struct HighLowVolumeNodes *handle);

struct HtPhasor *wickra_ht_phasor_new(void);

bool wickra_ht_phasor_update(struct HtPhasor *handle,
                             double value,
                             struct WickraHtPhasorOutput *out);

uintptr_t wickra_ht_phasor_warmup_period(struct HtPhasor *handle);

bool wickra_ht_phasor_is_ready(struct HtPhasor *handle);

const char *wickra_ht_phasor_name(struct HtPhasor *handle);

void wickra_ht_phasor_reset(struct HtPhasor *handle);

void wickra_ht_phasor_free(struct HtPhasor *handle);

struct HurstChannel *wickra_hurst_channel_new(uintptr_t period, double multiplier);

bool wickra_hurst_channel_update(struct HurstChannel *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraHurstChannelOutput *out);

uintptr_t wickra_hurst_channel_warmup_period(struct HurstChannel *handle);

bool wickra_hurst_channel_is_ready(struct HurstChannel *handle);

const char *wickra_hurst_channel_name(struct HurstChannel *handle);

void wickra_hurst_channel_reset(struct HurstChannel *handle);

void wickra_hurst_channel_free(struct HurstChannel *handle);

struct Ichimoku *wickra_ichimoku_new(uintptr_t tenkan_period,
                                     uintptr_t kijun_period,
                                     uintptr_t senkou_b_period,
                                     uintptr_t displacement);

bool wickra_ichimoku_update(struct Ichimoku *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp,
                            struct WickraIchimokuOutput *out);

uintptr_t wickra_ichimoku_warmup_period(struct Ichimoku *handle);

bool wickra_ichimoku_is_ready(struct Ichimoku *handle);

const char *wickra_ichimoku_name(struct Ichimoku *handle);

void wickra_ichimoku_reset(struct Ichimoku *handle);

void wickra_ichimoku_free(struct Ichimoku *handle);

struct InitialBalance *wickra_initial_balance_new(uintptr_t period);

bool wickra_initial_balance_update(struct InitialBalance *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp,
                                   struct WickraInitialBalanceOutput *out);

uintptr_t wickra_initial_balance_warmup_period(struct InitialBalance *handle);

bool wickra_initial_balance_is_ready(struct InitialBalance *handle);

const char *wickra_initial_balance_name(struct InitialBalance *handle);

void wickra_initial_balance_reset(struct InitialBalance *handle);

void wickra_initial_balance_free(struct InitialBalance *handle);

struct KalmanHedgeRatio *wickra_kalman_hedge_ratio_new(double delta, double observation_var);

bool wickra_kalman_hedge_ratio_update(struct KalmanHedgeRatio *handle,
                                      double x,
                                      double y,
                                      struct WickraKalmanHedgeRatioOutput *out);

uintptr_t wickra_kalman_hedge_ratio_warmup_period(struct KalmanHedgeRatio *handle);

bool wickra_kalman_hedge_ratio_is_ready(struct KalmanHedgeRatio *handle);

const char *wickra_kalman_hedge_ratio_name(struct KalmanHedgeRatio *handle);

void wickra_kalman_hedge_ratio_reset(struct KalmanHedgeRatio *handle);

void wickra_kalman_hedge_ratio_free(struct KalmanHedgeRatio *handle);

struct KaseDevStop *wickra_kase_dev_stop_new(uintptr_t period, double dev);

bool wickra_kase_dev_stop_update(struct KaseDevStop *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraKaseDevStopOutput *out);

uintptr_t wickra_kase_dev_stop_warmup_period(struct KaseDevStop *handle);

bool wickra_kase_dev_stop_is_ready(struct KaseDevStop *handle);

const char *wickra_kase_dev_stop_name(struct KaseDevStop *handle);

void wickra_kase_dev_stop_reset(struct KaseDevStop *handle);

void wickra_kase_dev_stop_free(struct KaseDevStop *handle);

struct KasePermissionStochastic *wickra_kase_permission_stochastic_new(uintptr_t length,
                                                                       uintptr_t smooth);

bool wickra_kase_permission_stochastic_update(struct KasePermissionStochastic *handle,
                                              double open,
                                              double high,
                                              double low,
                                              double close,
                                              double volume,
                                              int64_t timestamp,
                                              struct WickraKasePermissionStochasticOutput *out);

uintptr_t wickra_kase_permission_stochastic_warmup_period(struct KasePermissionStochastic *handle);

bool wickra_kase_permission_stochastic_is_ready(struct KasePermissionStochastic *handle);

const char *wickra_kase_permission_stochastic_name(struct KasePermissionStochastic *handle);

void wickra_kase_permission_stochastic_reset(struct KasePermissionStochastic *handle);

void wickra_kase_permission_stochastic_free(struct KasePermissionStochastic *handle);

struct Keltner *wickra_keltner_new(uintptr_t ema_period, uintptr_t atr_period, double multiplier);

bool wickra_keltner_update(struct Keltner *handle,
                           double open,
                           double high,
                           double low,
                           double close,
                           double volume,
                           int64_t timestamp,
                           struct WickraKeltnerOutput *out);

uintptr_t wickra_keltner_warmup_period(struct Keltner *handle);

bool wickra_keltner_is_ready(struct Keltner *handle);

const char *wickra_keltner_name(struct Keltner *handle);

void wickra_keltner_reset(struct Keltner *handle);

void wickra_keltner_free(struct Keltner *handle);

struct Kst *wickra_kst_new(uintptr_t roc1,
                           uintptr_t roc2,
                           uintptr_t roc3,
                           uintptr_t roc4,
                           uintptr_t sma1,
                           uintptr_t sma2,
                           uintptr_t sma3,
                           uintptr_t sma4,
                           uintptr_t signal);

bool wickra_kst_update(struct Kst *handle, double value, struct WickraKstOutput *out);

uintptr_t wickra_kst_warmup_period(struct Kst *handle);

bool wickra_kst_is_ready(struct Kst *handle);

const char *wickra_kst_name(struct Kst *handle);

void wickra_kst_reset(struct Kst *handle);

void wickra_kst_free(struct Kst *handle);

struct LeadLagCrossCorrelation *wickra_lead_lag_cross_correlation_new(uintptr_t window,
                                                                      uintptr_t max_lag);

bool wickra_lead_lag_cross_correlation_update(struct LeadLagCrossCorrelation *handle,
                                              double x,
                                              double y,
                                              struct WickraLeadLagCrossCorrelationOutput *out);

uintptr_t wickra_lead_lag_cross_correlation_warmup_period(struct LeadLagCrossCorrelation *handle);

bool wickra_lead_lag_cross_correlation_is_ready(struct LeadLagCrossCorrelation *handle);

const char *wickra_lead_lag_cross_correlation_name(struct LeadLagCrossCorrelation *handle);

void wickra_lead_lag_cross_correlation_reset(struct LeadLagCrossCorrelation *handle);

void wickra_lead_lag_cross_correlation_free(struct LeadLagCrossCorrelation *handle);

struct LinRegChannel *wickra_lin_reg_channel_new(uintptr_t period, double multiplier);

bool wickra_lin_reg_channel_update(struct LinRegChannel *handle,
                                   double value,
                                   struct WickraLinRegChannelOutput *out);

uintptr_t wickra_lin_reg_channel_warmup_period(struct LinRegChannel *handle);

bool wickra_lin_reg_channel_is_ready(struct LinRegChannel *handle);

const char *wickra_lin_reg_channel_name(struct LinRegChannel *handle);

void wickra_lin_reg_channel_reset(struct LinRegChannel *handle);

void wickra_lin_reg_channel_free(struct LinRegChannel *handle);

struct LiquidationFeatures *wickra_liquidation_features_new(void);

bool wickra_liquidation_features_update(struct LiquidationFeatures *handle,
                                        double funding_rate,
                                        double mark_price,
                                        double index_price,
                                        double futures_price,
                                        double open_interest,
                                        double long_size,
                                        double short_size,
                                        double taker_buy_volume,
                                        double taker_sell_volume,
                                        double long_liquidation,
                                        double short_liquidation,
                                        int64_t timestamp,
                                        struct WickraLiquidationFeaturesOutput *out);

uintptr_t wickra_liquidation_features_warmup_period(struct LiquidationFeatures *handle);

bool wickra_liquidation_features_is_ready(struct LiquidationFeatures *handle);

const char *wickra_liquidation_features_name(struct LiquidationFeatures *handle);

void wickra_liquidation_features_reset(struct LiquidationFeatures *handle);

void wickra_liquidation_features_free(struct LiquidationFeatures *handle);

struct MaEnvelope *wickra_ma_envelope_new(uintptr_t period, double percent);

bool wickra_ma_envelope_update(struct MaEnvelope *handle,
                               double value,
                               struct WickraMaEnvelopeOutput *out);

uintptr_t wickra_ma_envelope_warmup_period(struct MaEnvelope *handle);

bool wickra_ma_envelope_is_ready(struct MaEnvelope *handle);

const char *wickra_ma_envelope_name(struct MaEnvelope *handle);

void wickra_ma_envelope_reset(struct MaEnvelope *handle);

void wickra_ma_envelope_free(struct MaEnvelope *handle);

struct MacdIndicator *wickra_macd_indicator_new(uintptr_t fast, uintptr_t slow, uintptr_t signal);

bool wickra_macd_indicator_update(struct MacdIndicator *handle,
                                  double value,
                                  struct WickraMacdOutput *out);

uintptr_t wickra_macd_indicator_warmup_period(struct MacdIndicator *handle);

bool wickra_macd_indicator_is_ready(struct MacdIndicator *handle);

const char *wickra_macd_indicator_name(struct MacdIndicator *handle);

void wickra_macd_indicator_reset(struct MacdIndicator *handle);

void wickra_macd_indicator_free(struct MacdIndicator *handle);

struct MacdFix *wickra_macd_fix_new(uintptr_t signal);

bool wickra_macd_fix_update(struct MacdFix *handle, double value, struct WickraMacdOutput *out);

uintptr_t wickra_macd_fix_warmup_period(struct MacdFix *handle);

bool wickra_macd_fix_is_ready(struct MacdFix *handle);

const char *wickra_macd_fix_name(struct MacdFix *handle);

void wickra_macd_fix_reset(struct MacdFix *handle);

void wickra_macd_fix_free(struct MacdFix *handle);

struct Mama *wickra_mama_new(double fast_limit, double slow_limit);

bool wickra_mama_update(struct Mama *handle, double value, struct WickraMamaOutput *out);

uintptr_t wickra_mama_warmup_period(struct Mama *handle);

bool wickra_mama_is_ready(struct Mama *handle);

const char *wickra_mama_name(struct Mama *handle);

void wickra_mama_reset(struct Mama *handle);

void wickra_mama_free(struct Mama *handle);

struct MedianChannel *wickra_median_channel_new(uintptr_t period, double multiplier);

bool wickra_median_channel_update(struct MedianChannel *handle,
                                  double value,
                                  struct WickraMedianChannelOutput *out);

uintptr_t wickra_median_channel_warmup_period(struct MedianChannel *handle);

bool wickra_median_channel_is_ready(struct MedianChannel *handle);

const char *wickra_median_channel_name(struct MedianChannel *handle);

void wickra_median_channel_reset(struct MedianChannel *handle);

void wickra_median_channel_free(struct MedianChannel *handle);

struct ModifiedMaStop *wickra_modified_ma_stop_new(uintptr_t period);

bool wickra_modified_ma_stop_update(struct ModifiedMaStop *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp,
                                    struct WickraModifiedMaStopOutput *out);

uintptr_t wickra_modified_ma_stop_warmup_period(struct ModifiedMaStop *handle);

bool wickra_modified_ma_stop_is_ready(struct ModifiedMaStop *handle);

const char *wickra_modified_ma_stop_name(struct ModifiedMaStop *handle);

void wickra_modified_ma_stop_reset(struct ModifiedMaStop *handle);

void wickra_modified_ma_stop_free(struct ModifiedMaStop *handle);

struct MurreyMathLines *wickra_murrey_math_lines_new(uintptr_t period);

bool wickra_murrey_math_lines_update(struct MurreyMathLines *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp,
                                     struct WickraMurreyMathLinesOutput *out);

uintptr_t wickra_murrey_math_lines_warmup_period(struct MurreyMathLines *handle);

bool wickra_murrey_math_lines_is_ready(struct MurreyMathLines *handle);

const char *wickra_murrey_math_lines_name(struct MurreyMathLines *handle);

void wickra_murrey_math_lines_reset(struct MurreyMathLines *handle);

void wickra_murrey_math_lines_free(struct MurreyMathLines *handle);

struct Nrtr *wickra_nrtr_new(double pct);

bool wickra_nrtr_update(struct Nrtr *handle,
                        double open,
                        double high,
                        double low,
                        double close,
                        double volume,
                        int64_t timestamp,
                        struct WickraNrtrOutput *out);

uintptr_t wickra_nrtr_warmup_period(struct Nrtr *handle);

bool wickra_nrtr_is_ready(struct Nrtr *handle);

const char *wickra_nrtr_name(struct Nrtr *handle);

void wickra_nrtr_reset(struct Nrtr *handle);

void wickra_nrtr_free(struct Nrtr *handle);

struct OpeningRange *wickra_opening_range_new(uintptr_t period);

bool wickra_opening_range_update(struct OpeningRange *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraOpeningRangeOutput *out);

uintptr_t wickra_opening_range_warmup_period(struct OpeningRange *handle);

bool wickra_opening_range_is_ready(struct OpeningRange *handle);

const char *wickra_opening_range_name(struct OpeningRange *handle);

void wickra_opening_range_reset(struct OpeningRange *handle);

void wickra_opening_range_free(struct OpeningRange *handle);

struct OvernightIntradayReturn *wickra_overnight_intraday_return_new(int32_t utc_offset_minutes);

bool wickra_overnight_intraday_return_update(struct OvernightIntradayReturn *handle,
                                             double open,
                                             double high,
                                             double low,
                                             double close,
                                             double volume,
                                             int64_t timestamp,
                                             struct WickraOvernightIntradayReturnOutput *out);

uintptr_t wickra_overnight_intraday_return_warmup_period(struct OvernightIntradayReturn *handle);

bool wickra_overnight_intraday_return_is_ready(struct OvernightIntradayReturn *handle);

const char *wickra_overnight_intraday_return_name(struct OvernightIntradayReturn *handle);

void wickra_overnight_intraday_return_reset(struct OvernightIntradayReturn *handle);

void wickra_overnight_intraday_return_free(struct OvernightIntradayReturn *handle);

struct ProjectionBands *wickra_projection_bands_new(uintptr_t period);

bool wickra_projection_bands_update(struct ProjectionBands *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp,
                                    struct WickraProjectionBandsOutput *out);

uintptr_t wickra_projection_bands_warmup_period(struct ProjectionBands *handle);

bool wickra_projection_bands_is_ready(struct ProjectionBands *handle);

const char *wickra_projection_bands_name(struct ProjectionBands *handle);

void wickra_projection_bands_reset(struct ProjectionBands *handle);

void wickra_projection_bands_free(struct ProjectionBands *handle);

struct Qqe *wickra_qqe_new(uintptr_t rsi_period, uintptr_t smoothing, double factor);

bool wickra_qqe_update(struct Qqe *handle, double value, struct WickraQqeOutput *out);

uintptr_t wickra_qqe_warmup_period(struct Qqe *handle);

bool wickra_qqe_is_ready(struct Qqe *handle);

const char *wickra_qqe_name(struct Qqe *handle);

void wickra_qqe_reset(struct Qqe *handle);

void wickra_qqe_free(struct Qqe *handle);

struct QuartileBands *wickra_quartile_bands_new(uintptr_t period);

bool wickra_quartile_bands_update(struct QuartileBands *handle,
                                  double value,
                                  struct WickraQuartileBandsOutput *out);

uintptr_t wickra_quartile_bands_warmup_period(struct QuartileBands *handle);

bool wickra_quartile_bands_is_ready(struct QuartileBands *handle);

const char *wickra_quartile_bands_name(struct QuartileBands *handle);

void wickra_quartile_bands_reset(struct QuartileBands *handle);

void wickra_quartile_bands_free(struct QuartileBands *handle);

struct RelativeStrengthAB *wickra_relative_strength_ab_new(uintptr_t ma_period,
                                                           uintptr_t rsi_period);

bool wickra_relative_strength_ab_update(struct RelativeStrengthAB *handle,
                                        double x,
                                        double y,
                                        struct WickraRelativeStrengthOutput *out);

uintptr_t wickra_relative_strength_ab_warmup_period(struct RelativeStrengthAB *handle);

bool wickra_relative_strength_ab_is_ready(struct RelativeStrengthAB *handle);

const char *wickra_relative_strength_ab_name(struct RelativeStrengthAB *handle);

void wickra_relative_strength_ab_reset(struct RelativeStrengthAB *handle);

void wickra_relative_strength_ab_free(struct RelativeStrengthAB *handle);

struct Rwi *wickra_rwi_new(uintptr_t period);

bool wickra_rwi_update(struct Rwi *handle,
                       double open,
                       double high,
                       double low,
                       double close,
                       double volume,
                       int64_t timestamp,
                       struct WickraRwiOutput *out);

uintptr_t wickra_rwi_warmup_period(struct Rwi *handle);

bool wickra_rwi_is_ready(struct Rwi *handle);

const char *wickra_rwi_name(struct Rwi *handle);

void wickra_rwi_reset(struct Rwi *handle);

void wickra_rwi_free(struct Rwi *handle);

struct SessionHighLow *wickra_session_high_low_new(int32_t utc_offset_minutes);

bool wickra_session_high_low_update(struct SessionHighLow *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp,
                                    struct WickraSessionHighLowOutput *out);

uintptr_t wickra_session_high_low_warmup_period(struct SessionHighLow *handle);

bool wickra_session_high_low_is_ready(struct SessionHighLow *handle);

const char *wickra_session_high_low_name(struct SessionHighLow *handle);

void wickra_session_high_low_reset(struct SessionHighLow *handle);

void wickra_session_high_low_free(struct SessionHighLow *handle);

struct SessionRange *wickra_session_range_new(int32_t utc_offset_minutes);

bool wickra_session_range_update(struct SessionRange *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraSessionRangeOutput *out);

uintptr_t wickra_session_range_warmup_period(struct SessionRange *handle);

bool wickra_session_range_is_ready(struct SessionRange *handle);

const char *wickra_session_range_name(struct SessionRange *handle);

void wickra_session_range_reset(struct SessionRange *handle);

void wickra_session_range_free(struct SessionRange *handle);

struct SmoothedHeikinAshi *wickra_smoothed_heikin_ashi_new(uintptr_t period);

bool wickra_smoothed_heikin_ashi_update(struct SmoothedHeikinAshi *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp,
                                        struct WickraSmoothedHeikinAshiOutput *out);

uintptr_t wickra_smoothed_heikin_ashi_warmup_period(struct SmoothedHeikinAshi *handle);

bool wickra_smoothed_heikin_ashi_is_ready(struct SmoothedHeikinAshi *handle);

const char *wickra_smoothed_heikin_ashi_name(struct SmoothedHeikinAshi *handle);

void wickra_smoothed_heikin_ashi_reset(struct SmoothedHeikinAshi *handle);

void wickra_smoothed_heikin_ashi_free(struct SmoothedHeikinAshi *handle);

struct SpreadBollingerBands *wickra_spread_bollinger_bands_new(uintptr_t period, double num_std);

bool wickra_spread_bollinger_bands_update(struct SpreadBollingerBands *handle,
                                          double x,
                                          double y,
                                          struct WickraSpreadBollingerBandsOutput *out);

uintptr_t wickra_spread_bollinger_bands_warmup_period(struct SpreadBollingerBands *handle);

bool wickra_spread_bollinger_bands_is_ready(struct SpreadBollingerBands *handle);

const char *wickra_spread_bollinger_bands_name(struct SpreadBollingerBands *handle);

void wickra_spread_bollinger_bands_reset(struct SpreadBollingerBands *handle);

void wickra_spread_bollinger_bands_free(struct SpreadBollingerBands *handle);

struct StandardErrorBands *wickra_standard_error_bands_new(uintptr_t period, double multiplier);

bool wickra_standard_error_bands_update(struct StandardErrorBands *handle,
                                        double value,
                                        struct WickraStandardErrorBandsOutput *out);

uintptr_t wickra_standard_error_bands_warmup_period(struct StandardErrorBands *handle);

bool wickra_standard_error_bands_is_ready(struct StandardErrorBands *handle);

const char *wickra_standard_error_bands_name(struct StandardErrorBands *handle);

void wickra_standard_error_bands_reset(struct StandardErrorBands *handle);

void wickra_standard_error_bands_free(struct StandardErrorBands *handle);

struct StarcBands *wickra_starc_bands_new(uintptr_t sma_period,
                                          uintptr_t atr_period,
                                          double multiplier);

bool wickra_starc_bands_update(struct StarcBands *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp,
                               struct WickraStarcBandsOutput *out);

uintptr_t wickra_starc_bands_warmup_period(struct StarcBands *handle);

bool wickra_starc_bands_is_ready(struct StarcBands *handle);

const char *wickra_starc_bands_name(struct StarcBands *handle);

void wickra_starc_bands_reset(struct StarcBands *handle);

void wickra_starc_bands_free(struct StarcBands *handle);

struct Stochastic *wickra_stochastic_new(uintptr_t k_period, uintptr_t d_period);

bool wickra_stochastic_update(struct Stochastic *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp,
                              struct WickraStochasticOutput *out);

uintptr_t wickra_stochastic_warmup_period(struct Stochastic *handle);

bool wickra_stochastic_is_ready(struct Stochastic *handle);

const char *wickra_stochastic_name(struct Stochastic *handle);

void wickra_stochastic_reset(struct Stochastic *handle);

void wickra_stochastic_free(struct Stochastic *handle);

struct SuperTrend *wickra_super_trend_new(uintptr_t atr_period, double multiplier);

bool wickra_super_trend_update(struct SuperTrend *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp,
                               struct WickraSuperTrendOutput *out);

uintptr_t wickra_super_trend_warmup_period(struct SuperTrend *handle);

bool wickra_super_trend_is_ready(struct SuperTrend *handle);

const char *wickra_super_trend_name(struct SuperTrend *handle);

void wickra_super_trend_reset(struct SuperTrend *handle);

void wickra_super_trend_free(struct SuperTrend *handle);

struct TdLines *wickra_td_lines_new(uintptr_t lookback, uintptr_t target);

bool wickra_td_lines_update(struct TdLines *handle,
                            double open,
                            double high,
                            double low,
                            double close,
                            double volume,
                            int64_t timestamp,
                            struct WickraTdLinesOutput *out);

uintptr_t wickra_td_lines_warmup_period(struct TdLines *handle);

bool wickra_td_lines_is_ready(struct TdLines *handle);

const char *wickra_td_lines_name(struct TdLines *handle);

void wickra_td_lines_reset(struct TdLines *handle);

void wickra_td_lines_free(struct TdLines *handle);

struct TdMovingAverage *wickra_td_moving_average_new(uintptr_t period_st1, uintptr_t period_st2);

bool wickra_td_moving_average_update(struct TdMovingAverage *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp,
                                     struct WickraTdMovingAverageOutput *out);

uintptr_t wickra_td_moving_average_warmup_period(struct TdMovingAverage *handle);

bool wickra_td_moving_average_is_ready(struct TdMovingAverage *handle);

const char *wickra_td_moving_average_name(struct TdMovingAverage *handle);

void wickra_td_moving_average_reset(struct TdMovingAverage *handle);

void wickra_td_moving_average_free(struct TdMovingAverage *handle);

struct TdRangeProjection *wickra_td_range_projection_new(void);

bool wickra_td_range_projection_update(struct TdRangeProjection *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp,
                                       struct WickraTdRangeProjectionOutput *out);

uintptr_t wickra_td_range_projection_warmup_period(struct TdRangeProjection *handle);

bool wickra_td_range_projection_is_ready(struct TdRangeProjection *handle);

const char *wickra_td_range_projection_name(struct TdRangeProjection *handle);

void wickra_td_range_projection_reset(struct TdRangeProjection *handle);

void wickra_td_range_projection_free(struct TdRangeProjection *handle);

struct TdRiskLevel *wickra_td_risk_level_new(uintptr_t lookback, uintptr_t target);

bool wickra_td_risk_level_update(struct TdRiskLevel *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraTdRiskLevelOutput *out);

uintptr_t wickra_td_risk_level_warmup_period(struct TdRiskLevel *handle);

bool wickra_td_risk_level_is_ready(struct TdRiskLevel *handle);

const char *wickra_td_risk_level_name(struct TdRiskLevel *handle);

void wickra_td_risk_level_reset(struct TdRiskLevel *handle);

void wickra_td_risk_level_free(struct TdRiskLevel *handle);

struct TdSequential *wickra_td_sequential_new(uintptr_t setup_lookback,
                                              uintptr_t setup_target,
                                              uintptr_t countdown_lookback,
                                              uintptr_t countdown_target);

bool wickra_td_sequential_update(struct TdSequential *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraTdSequentialOutput *out);

uintptr_t wickra_td_sequential_warmup_period(struct TdSequential *handle);

bool wickra_td_sequential_is_ready(struct TdSequential *handle);

const char *wickra_td_sequential_name(struct TdSequential *handle);

void wickra_td_sequential_reset(struct TdSequential *handle);

void wickra_td_sequential_free(struct TdSequential *handle);

struct TtmSqueeze *wickra_ttm_squeeze_new(uintptr_t period, double bb_mult, double kc_mult);

bool wickra_ttm_squeeze_update(struct TtmSqueeze *handle,
                               double open,
                               double high,
                               double low,
                               double close,
                               double volume,
                               int64_t timestamp,
                               struct WickraTtmSqueezeOutput *out);

uintptr_t wickra_ttm_squeeze_warmup_period(struct TtmSqueeze *handle);

bool wickra_ttm_squeeze_is_ready(struct TtmSqueeze *handle);

const char *wickra_ttm_squeeze_name(struct TtmSqueeze *handle);

void wickra_ttm_squeeze_reset(struct TtmSqueeze *handle);

void wickra_ttm_squeeze_free(struct TtmSqueeze *handle);

struct ValueArea *wickra_value_area_new(uintptr_t period,
                                        uintptr_t bin_count,
                                        double value_area_pct);

bool wickra_value_area_update(struct ValueArea *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp,
                              struct WickraValueAreaOutput *out);

uintptr_t wickra_value_area_warmup_period(struct ValueArea *handle);

bool wickra_value_area_is_ready(struct ValueArea *handle);

const char *wickra_value_area_name(struct ValueArea *handle);

void wickra_value_area_reset(struct ValueArea *handle);

void wickra_value_area_free(struct ValueArea *handle);

struct VolatilityCone *wickra_volatility_cone_new(uintptr_t window, uintptr_t lookback);

bool wickra_volatility_cone_update(struct VolatilityCone *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp,
                                   struct WickraVolatilityConeOutput *out);

uintptr_t wickra_volatility_cone_warmup_period(struct VolatilityCone *handle);

bool wickra_volatility_cone_is_ready(struct VolatilityCone *handle);

const char *wickra_volatility_cone_name(struct VolatilityCone *handle);

void wickra_volatility_cone_reset(struct VolatilityCone *handle);

void wickra_volatility_cone_free(struct VolatilityCone *handle);

struct VolumeWeightedMacd *wickra_volume_weighted_macd_new(uintptr_t fast,
                                                           uintptr_t slow,
                                                           uintptr_t signal);

bool wickra_volume_weighted_macd_update(struct VolumeWeightedMacd *handle,
                                        double open,
                                        double high,
                                        double low,
                                        double close,
                                        double volume,
                                        int64_t timestamp,
                                        struct WickraVolumeWeightedMacdOutput *out);

uintptr_t wickra_volume_weighted_macd_warmup_period(struct VolumeWeightedMacd *handle);

bool wickra_volume_weighted_macd_is_ready(struct VolumeWeightedMacd *handle);

const char *wickra_volume_weighted_macd_name(struct VolumeWeightedMacd *handle);

void wickra_volume_weighted_macd_reset(struct VolumeWeightedMacd *handle);

void wickra_volume_weighted_macd_free(struct VolumeWeightedMacd *handle);

struct VolumeWeightedSr *wickra_volume_weighted_sr_new(uintptr_t period);

bool wickra_volume_weighted_sr_update(struct VolumeWeightedSr *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp,
                                      struct WickraVolumeWeightedSrOutput *out);

uintptr_t wickra_volume_weighted_sr_warmup_period(struct VolumeWeightedSr *handle);

bool wickra_volume_weighted_sr_is_ready(struct VolumeWeightedSr *handle);

const char *wickra_volume_weighted_sr_name(struct VolumeWeightedSr *handle);

void wickra_volume_weighted_sr_reset(struct VolumeWeightedSr *handle);

void wickra_volume_weighted_sr_free(struct VolumeWeightedSr *handle);

struct Vortex *wickra_vortex_new(uintptr_t period);

bool wickra_vortex_update(struct Vortex *handle,
                          double open,
                          double high,
                          double low,
                          double close,
                          double volume,
                          int64_t timestamp,
                          struct WickraVortexOutput *out);

uintptr_t wickra_vortex_warmup_period(struct Vortex *handle);

bool wickra_vortex_is_ready(struct Vortex *handle);

const char *wickra_vortex_name(struct Vortex *handle);

void wickra_vortex_reset(struct Vortex *handle);

void wickra_vortex_free(struct Vortex *handle);

struct VwapStdDevBands *wickra_vwap_std_dev_bands_new(double multiplier);

bool wickra_vwap_std_dev_bands_update(struct VwapStdDevBands *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp,
                                      struct WickraVwapStdDevBandsOutput *out);

uintptr_t wickra_vwap_std_dev_bands_warmup_period(struct VwapStdDevBands *handle);

bool wickra_vwap_std_dev_bands_is_ready(struct VwapStdDevBands *handle);

const char *wickra_vwap_std_dev_bands_name(struct VwapStdDevBands *handle);

void wickra_vwap_std_dev_bands_reset(struct VwapStdDevBands *handle);

void wickra_vwap_std_dev_bands_free(struct VwapStdDevBands *handle);

struct WaveTrend *wickra_wave_trend_new(uintptr_t channel_period,
                                        uintptr_t average_period,
                                        uintptr_t signal_period);

bool wickra_wave_trend_update(struct WaveTrend *handle,
                              double open,
                              double high,
                              double low,
                              double close,
                              double volume,
                              int64_t timestamp,
                              struct WickraWaveTrendOutput *out);

uintptr_t wickra_wave_trend_warmup_period(struct WaveTrend *handle);

bool wickra_wave_trend_is_ready(struct WaveTrend *handle);

const char *wickra_wave_trend_name(struct WaveTrend *handle);

void wickra_wave_trend_reset(struct WaveTrend *handle);

void wickra_wave_trend_free(struct WaveTrend *handle);

struct WilliamsFractals *wickra_williams_fractals_new(void);

bool wickra_williams_fractals_update(struct WilliamsFractals *handle,
                                     double open,
                                     double high,
                                     double low,
                                     double close,
                                     double volume,
                                     int64_t timestamp,
                                     struct WickraWilliamsFractalsOutput *out);

uintptr_t wickra_williams_fractals_warmup_period(struct WilliamsFractals *handle);

bool wickra_williams_fractals_is_ready(struct WilliamsFractals *handle);

const char *wickra_williams_fractals_name(struct WilliamsFractals *handle);

void wickra_williams_fractals_reset(struct WilliamsFractals *handle);

void wickra_williams_fractals_free(struct WilliamsFractals *handle);

struct WoodiePivots *wickra_woodie_pivots_new(void);

bool wickra_woodie_pivots_update(struct WoodiePivots *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraWoodiePivotsOutput *out);

uintptr_t wickra_woodie_pivots_warmup_period(struct WoodiePivots *handle);

bool wickra_woodie_pivots_is_ready(struct WoodiePivots *handle);

const char *wickra_woodie_pivots_name(struct WoodiePivots *handle);

void wickra_woodie_pivots_reset(struct WoodiePivots *handle);

void wickra_woodie_pivots_free(struct WoodiePivots *handle);

struct ZeroLagMacd *wickra_zero_lag_macd_new(uintptr_t fast, uintptr_t slow, uintptr_t signal);

bool wickra_zero_lag_macd_update(struct ZeroLagMacd *handle,
                                 double value,
                                 struct WickraZeroLagMacdOutput *out);

uintptr_t wickra_zero_lag_macd_warmup_period(struct ZeroLagMacd *handle);

bool wickra_zero_lag_macd_is_ready(struct ZeroLagMacd *handle);

const char *wickra_zero_lag_macd_name(struct ZeroLagMacd *handle);

void wickra_zero_lag_macd_reset(struct ZeroLagMacd *handle);

void wickra_zero_lag_macd_free(struct ZeroLagMacd *handle);

struct ZigZag *wickra_zig_zag_new(double threshold);

bool wickra_zig_zag_update(struct ZigZag *handle,
                           double open,
                           double high,
                           double low,
                           double close,
                           double volume,
                           int64_t timestamp,
                           struct WickraZigZagOutput *out);

uintptr_t wickra_zig_zag_warmup_period(struct ZigZag *handle);

bool wickra_zig_zag_is_ready(struct ZigZag *handle);

const char *wickra_zig_zag_name(struct ZigZag *handle);

void wickra_zig_zag_reset(struct ZigZag *handle);

void wickra_zig_zag_free(struct ZigZag *handle);

struct DayOfWeekProfile *wickra_day_of_week_profile_new(int32_t utc_offset_minutes);

intptr_t wickra_day_of_week_profile_update(struct DayOfWeekProfile *handle,
                                           double open,
                                           double high,
                                           double low,
                                           double close,
                                           double volume,
                                           int64_t timestamp,
                                           double *values,
                                           uintptr_t cap);

uintptr_t wickra_day_of_week_profile_warmup_period(struct DayOfWeekProfile *handle);

bool wickra_day_of_week_profile_is_ready(struct DayOfWeekProfile *handle);

const char *wickra_day_of_week_profile_name(struct DayOfWeekProfile *handle);

void wickra_day_of_week_profile_reset(struct DayOfWeekProfile *handle);

void wickra_day_of_week_profile_free(struct DayOfWeekProfile *handle);

struct IntradayVolatilityProfile *wickra_intraday_volatility_profile_new(uintptr_t buckets,
                                                                         int32_t utc_offset_minutes);

intptr_t wickra_intraday_volatility_profile_update(struct IntradayVolatilityProfile *handle,
                                                   double open,
                                                   double high,
                                                   double low,
                                                   double close,
                                                   double volume,
                                                   int64_t timestamp,
                                                   double *values,
                                                   uintptr_t cap);

uintptr_t wickra_intraday_volatility_profile_warmup_period(struct IntradayVolatilityProfile *handle);

bool wickra_intraday_volatility_profile_is_ready(struct IntradayVolatilityProfile *handle);

const char *wickra_intraday_volatility_profile_name(struct IntradayVolatilityProfile *handle);

void wickra_intraday_volatility_profile_reset(struct IntradayVolatilityProfile *handle);

void wickra_intraday_volatility_profile_free(struct IntradayVolatilityProfile *handle);

struct TimeOfDayReturnProfile *wickra_time_of_day_return_profile_new(uintptr_t buckets,
                                                                     int32_t utc_offset_minutes);

intptr_t wickra_time_of_day_return_profile_update(struct TimeOfDayReturnProfile *handle,
                                                  double open,
                                                  double high,
                                                  double low,
                                                  double close,
                                                  double volume,
                                                  int64_t timestamp,
                                                  double *values,
                                                  uintptr_t cap);

uintptr_t wickra_time_of_day_return_profile_warmup_period(struct TimeOfDayReturnProfile *handle);

bool wickra_time_of_day_return_profile_is_ready(struct TimeOfDayReturnProfile *handle);

const char *wickra_time_of_day_return_profile_name(struct TimeOfDayReturnProfile *handle);

void wickra_time_of_day_return_profile_reset(struct TimeOfDayReturnProfile *handle);

void wickra_time_of_day_return_profile_free(struct TimeOfDayReturnProfile *handle);

struct TpoProfile *wickra_tpo_profile_new(uintptr_t period, uintptr_t bin_count);

intptr_t wickra_tpo_profile_update(struct TpoProfile *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp,
                                   struct WickraTpoProfileOutputScalars *scalars,
                                   double *values,
                                   uintptr_t cap);

uintptr_t wickra_tpo_profile_warmup_period(struct TpoProfile *handle);

bool wickra_tpo_profile_is_ready(struct TpoProfile *handle);

const char *wickra_tpo_profile_name(struct TpoProfile *handle);

void wickra_tpo_profile_reset(struct TpoProfile *handle);

void wickra_tpo_profile_free(struct TpoProfile *handle);

struct VolumeByTimeProfile *wickra_volume_by_time_profile_new(uintptr_t buckets,
                                                              int32_t utc_offset_minutes);

intptr_t wickra_volume_by_time_profile_update(struct VolumeByTimeProfile *handle,
                                              double open,
                                              double high,
                                              double low,
                                              double close,
                                              double volume,
                                              int64_t timestamp,
                                              double *values,
                                              uintptr_t cap);

uintptr_t wickra_volume_by_time_profile_warmup_period(struct VolumeByTimeProfile *handle);

bool wickra_volume_by_time_profile_is_ready(struct VolumeByTimeProfile *handle);

const char *wickra_volume_by_time_profile_name(struct VolumeByTimeProfile *handle);

void wickra_volume_by_time_profile_reset(struct VolumeByTimeProfile *handle);

void wickra_volume_by_time_profile_free(struct VolumeByTimeProfile *handle);

struct VolumeProfile *wickra_volume_profile_new(uintptr_t period, uintptr_t bin_count);

intptr_t wickra_volume_profile_update(struct VolumeProfile *handle,
                                      double open,
                                      double high,
                                      double low,
                                      double close,
                                      double volume,
                                      int64_t timestamp,
                                      struct WickraVolumeProfileOutputScalars *scalars,
                                      double *values,
                                      uintptr_t cap);

uintptr_t wickra_volume_profile_warmup_period(struct VolumeProfile *handle);

bool wickra_volume_profile_is_ready(struct VolumeProfile *handle);

const char *wickra_volume_profile_name(struct VolumeProfile *handle);

void wickra_volume_profile_reset(struct VolumeProfile *handle);

void wickra_volume_profile_free(struct VolumeProfile *handle);

struct DollarBars *wickra_dollar_bars_new(double dollar_per_bar);

uintptr_t wickra_dollar_bars_update(struct DollarBars *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp,
                                    struct WickraDollarBar *out,
                                    uintptr_t cap);

const char *wickra_dollar_bars_name(struct DollarBars *handle);

void wickra_dollar_bars_reset(struct DollarBars *handle);

void wickra_dollar_bars_free(struct DollarBars *handle);

struct ImbalanceBars *wickra_imbalance_bars_new(double threshold);

uintptr_t wickra_imbalance_bars_update(struct ImbalanceBars *handle,
                                       double open,
                                       double high,
                                       double low,
                                       double close,
                                       double volume,
                                       int64_t timestamp,
                                       struct WickraImbalanceBar *out,
                                       uintptr_t cap);

const char *wickra_imbalance_bars_name(struct ImbalanceBars *handle);

void wickra_imbalance_bars_reset(struct ImbalanceBars *handle);

void wickra_imbalance_bars_free(struct ImbalanceBars *handle);

struct KagiBars *wickra_kagi_bars_new(double reversal);

uintptr_t wickra_kagi_bars_update(struct KagiBars *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp,
                                  struct WickraKagiBar *out,
                                  uintptr_t cap);

const char *wickra_kagi_bars_name(struct KagiBars *handle);

void wickra_kagi_bars_reset(struct KagiBars *handle);

void wickra_kagi_bars_free(struct KagiBars *handle);

struct PointAndFigureBars *wickra_point_and_figure_bars_new(double box_size, uintptr_t reversal);

uintptr_t wickra_point_and_figure_bars_update(struct PointAndFigureBars *handle,
                                              double open,
                                              double high,
                                              double low,
                                              double close,
                                              double volume,
                                              int64_t timestamp,
                                              struct WickraPnfColumn *out,
                                              uintptr_t cap);

const char *wickra_point_and_figure_bars_name(struct PointAndFigureBars *handle);

void wickra_point_and_figure_bars_reset(struct PointAndFigureBars *handle);

void wickra_point_and_figure_bars_free(struct PointAndFigureBars *handle);

struct RangeBars *wickra_range_bars_new(double range);

uintptr_t wickra_range_bars_update(struct RangeBars *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp,
                                   struct WickraRangeBar *out,
                                   uintptr_t cap);

const char *wickra_range_bars_name(struct RangeBars *handle);

void wickra_range_bars_reset(struct RangeBars *handle);

void wickra_range_bars_free(struct RangeBars *handle);

struct RenkoBars *wickra_renko_bars_new(double box_size);

uintptr_t wickra_renko_bars_update(struct RenkoBars *handle,
                                   double open,
                                   double high,
                                   double low,
                                   double close,
                                   double volume,
                                   int64_t timestamp,
                                   struct WickraRenkoBrick *out,
                                   uintptr_t cap);

const char *wickra_renko_bars_name(struct RenkoBars *handle);

void wickra_renko_bars_reset(struct RenkoBars *handle);

void wickra_renko_bars_free(struct RenkoBars *handle);

struct RunBars *wickra_run_bars_new(uintptr_t run_length);

uintptr_t wickra_run_bars_update(struct RunBars *handle,
                                 double open,
                                 double high,
                                 double low,
                                 double close,
                                 double volume,
                                 int64_t timestamp,
                                 struct WickraRunBar *out,
                                 uintptr_t cap);

const char *wickra_run_bars_name(struct RunBars *handle);

void wickra_run_bars_reset(struct RunBars *handle);

void wickra_run_bars_free(struct RunBars *handle);

struct ThreeLineBreakBars *wickra_three_line_break_bars_new(uintptr_t lines);

uintptr_t wickra_three_line_break_bars_update(struct ThreeLineBreakBars *handle,
                                              double open,
                                              double high,
                                              double low,
                                              double close,
                                              double volume,
                                              int64_t timestamp,
                                              struct WickraLineBreakBar *out,
                                              uintptr_t cap);

const char *wickra_three_line_break_bars_name(struct ThreeLineBreakBars *handle);

void wickra_three_line_break_bars_reset(struct ThreeLineBreakBars *handle);

void wickra_three_line_break_bars_free(struct ThreeLineBreakBars *handle);

struct TickBars *wickra_tick_bars_new(uintptr_t ticks);

uintptr_t wickra_tick_bars_update(struct TickBars *handle,
                                  double open,
                                  double high,
                                  double low,
                                  double close,
                                  double volume,
                                  int64_t timestamp,
                                  struct WickraTickBar *out,
                                  uintptr_t cap);

const char *wickra_tick_bars_name(struct TickBars *handle);

void wickra_tick_bars_reset(struct TickBars *handle);

void wickra_tick_bars_free(struct TickBars *handle);

struct VolumeBars *wickra_volume_bars_new(double volume_per_bar);

uintptr_t wickra_volume_bars_update(struct VolumeBars *handle,
                                    double open,
                                    double high,
                                    double low,
                                    double close,
                                    double volume,
                                    int64_t timestamp,
                                    struct WickraVolumeBar *out,
                                    uintptr_t cap);

const char *wickra_volume_bars_name(struct VolumeBars *handle);

void wickra_volume_bars_reset(struct VolumeBars *handle);

void wickra_volume_bars_free(struct VolumeBars *handle);

struct MacdExt *wickra_macd_ext_new(uintptr_t fast,
                                    uint8_t fast_type,
                                    uintptr_t slow,
                                    uint8_t slow_type,
                                    uintptr_t signal,
                                    uint8_t signal_type);

bool wickra_macd_ext_update(struct MacdExt *handle, double value, struct WickraMacdOutput *out);

uintptr_t wickra_macd_ext_warmup_period(struct MacdExt *handle);

bool wickra_macd_ext_is_ready(struct MacdExt *handle);

const char *wickra_macd_ext_name(struct MacdExt *handle);

void wickra_macd_ext_reset(struct MacdExt *handle);

void wickra_macd_ext_free(struct MacdExt *handle);

struct Footprint *wickra_footprint_new(double tick_size);

intptr_t wickra_footprint_update(struct Footprint *handle,
                                 double price,
                                 double size,
                                 bool is_buy,
                                 int64_t timestamp,
                                 struct WickraFootprintLevel *out,
                                 uintptr_t cap);

uintptr_t wickra_footprint_warmup_period(struct Footprint *handle);

bool wickra_footprint_is_ready(struct Footprint *handle);

const char *wickra_footprint_name(struct Footprint *handle);

void wickra_footprint_reset(struct Footprint *handle);

void wickra_footprint_free(struct Footprint *handle);

struct TickAggregator *wickra_tick_aggregator_new(int64_t bucket, bool gap_fill);

intptr_t wickra_tick_aggregator_push(struct TickAggregator *handle,
                                     double price,
                                     double size,
                                     int64_t timestamp);

intptr_t wickra_tick_aggregator_drain(struct TickAggregator *handle,
                                      struct WickraCandle *out,
                                      uintptr_t cap);

void wickra_tick_aggregator_free(struct TickAggregator *handle);

struct Resampler *wickra_resampler_new(int64_t timeframe);

bool wickra_resampler_update(struct Resampler *handle,
                             double open,
                             double high,
                             double low,
                             double close,
                             double volume,
                             int64_t timestamp,
                             struct WickraCandle *out);

bool wickra_resampler_flush(struct Resampler *handle, struct WickraCandle *out);

void wickra_resampler_free(struct Resampler *handle);

struct CandleReader *wickra_candle_reader_new(const uint8_t *data, uintptr_t len);

uintptr_t wickra_candle_reader_count(const struct CandleReader *handle);

uintptr_t wickra_candle_reader_read(struct CandleReader *handle,
                                    struct WickraCandle *out,
                                    uintptr_t cap);

void wickra_candle_reader_free(struct CandleReader *handle);

#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus

#endif  /* WICKRA_H */