trading-signals 7.2.0 → 7.4.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.cts CHANGED
@@ -1,472 +1,494 @@
1
+ //#region src/error/NotEnoughDataError.d.ts
1
2
  declare class NotEnoughDataError extends Error {
2
- constructor(requiredAmount: number);
3
+ constructor(requiredAmount: number);
3
4
  }
4
-
5
+ //#endregion
6
+ //#region src/types/Indicator.d.ts
5
7
  type Nullable<Result> = Result | null;
6
8
  interface Indicator<Result = number, Input = number> {
7
- isStable: boolean;
8
- add(input: Input): Nullable<Result>;
9
- getRequiredInputs(): number;
10
- getResult(): Nullable<Result>;
11
- getResultOrThrow(): Result;
12
- replace(input: Input): Nullable<Result>;
13
- update(input: Input, replace: boolean): Nullable<Result>;
14
- updates(input: Input[], replace: boolean): Nullable<Result>[];
9
+ isStable: boolean;
10
+ add(input: Input): Nullable<Result>;
11
+ getRequiredInputs(): number;
12
+ getResult(): Nullable<Result>;
13
+ getResultOrThrow(): Result;
14
+ replace(input: Input): Nullable<Result>;
15
+ update(input: Input, replace: boolean): Nullable<Result>;
16
+ updates(input: Input[], replace: boolean): Nullable<Result>[];
15
17
  }
16
18
  declare const TradingSignal: {
17
- readonly BEARISH: "BEARISH";
18
- readonly BULLISH: "BULLISH";
19
- readonly SIDEWAYS: "SIDEWAYS";
20
- readonly UNKNOWN: "UNKNOWN";
19
+ readonly BEARISH: "BEARISH";
20
+ readonly BULLISH: "BULLISH";
21
+ readonly SIDEWAYS: "SIDEWAYS";
22
+ readonly UNKNOWN: "UNKNOWN";
21
23
  };
22
24
  type TradingSignals = (typeof TradingSignal)[keyof typeof TradingSignal];
23
25
  declare abstract class TechnicalIndicator<Result, Input> implements Indicator<Result, Input> {
24
- protected result: Result | undefined;
25
- abstract getRequiredInputs(): number;
26
- getResult(): (Result & {}) | null;
27
- getResultOrThrow(): Result & ({} | null);
28
- get isStable(): boolean;
29
- add(input: Input): Result | null;
30
- replace(input: Input): Result | null;
31
- abstract update(input: Input, replace: boolean): Result | null;
32
- updates(inputs: readonly Input[], replace?: boolean): (Result | null)[];
26
+ protected result: Result | undefined;
27
+ abstract getRequiredInputs(): number;
28
+ getResult(): (Result & {}) | null;
29
+ getResultOrThrow(): Result & ({} | null);
30
+ get isStable(): boolean;
31
+ add(input: Input): Result | null;
32
+ replace(input: Input): Result | null;
33
+ abstract update(input: Input, replace: boolean): Result | null;
34
+ updates(inputs: readonly Input[], replace?: boolean): (Result | null)[];
33
35
  }
34
36
  declare abstract class IndicatorSeries<Input = number> extends TechnicalIndicator<number, Input> {
35
- protected previousResult?: number;
36
- protected setResult(value: number, replace: boolean): number;
37
+ protected previousResult?: number;
38
+ protected setResult(value: number, replace: boolean): number;
37
39
  }
38
40
  declare abstract class TrendIndicatorSeries<Input = number, SignalState = TradingSignals> extends IndicatorSeries<Input> {
39
- protected abstract calculateSignalState(result?: number | null | undefined): SignalState;
40
- private previousSignalState?;
41
- protected setResult(value: number, replace: boolean): number;
42
- getSignal(): {
43
- state: SignalState;
44
- hasChanged: boolean;
45
- };
46
- }
47
-
41
+ #private;
42
+ protected abstract calculateSignalState(result?: number | null | undefined): SignalState;
43
+ protected setResult(value: number, replace: boolean): number;
44
+ getSignal(): {
45
+ state: SignalState;
46
+ hasChanged: boolean;
47
+ };
48
+ }
49
+ //#endregion
50
+ //#region src/trend/MA/MovingAverage.d.ts
48
51
  declare abstract class MovingAverage extends IndicatorSeries {
49
- readonly interval: number;
50
- constructor(interval: number);
52
+ readonly interval: number;
53
+ constructor(interval: number);
51
54
  }
52
-
55
+ //#endregion
56
+ //#region src/trend/SMA/SMA.d.ts
53
57
  declare class SMA extends MovingAverage {
54
- readonly prices: number[];
55
- getRequiredInputs(): number;
56
- update(price: number, replace: boolean): number | null;
58
+ readonly prices: number[];
59
+ getRequiredInputs(): number;
60
+ update(price: number, replace: boolean): number | null;
57
61
  }
58
-
62
+ //#endregion
63
+ //#region src/types/HighLowClose.d.ts
59
64
  type HighLow<T = number> = {
60
- high: T;
61
- low: T;
65
+ high: T;
66
+ low: T;
62
67
  };
63
68
  type HighLowClose<T = number> = HighLow<T> & {
64
- close: T;
69
+ close: T;
65
70
  };
66
71
  type OpenHighLowClose<T = number> = HighLowClose<T> & {
67
- open: T;
72
+ open: T;
68
73
  };
69
74
  type OpenHighLowCloseVolume<T = number> = OpenHighLowClose<T> & {
70
- volume: T;
75
+ volume: T;
71
76
  };
72
77
  type HighLowCloseVolume<T = number> = Omit<OpenHighLowCloseVolume<T>, 'open'>;
73
-
78
+ //#endregion
79
+ //#region src/trend/EMA/EMA.d.ts
74
80
  declare class EMA extends MovingAverage {
75
- readonly interval: number;
76
- private pricesCounter;
77
- private readonly weightFactor;
78
- constructor(interval: number);
79
- getRequiredInputs(): number;
80
- update(price: number, replace: boolean): number;
81
- getResultOrThrow(): number;
82
- get isStable(): boolean;
83
- }
84
-
81
+ #private;
82
+ readonly interval: number;
83
+ constructor(interval: number);
84
+ getRequiredInputs(): number;
85
+ update(price: number, replace: boolean): number;
86
+ getResultOrThrow(): number;
87
+ get isStable(): boolean;
88
+ }
89
+ //#endregion
90
+ //#region src/trend/RMA/RMA.d.ts
85
91
  declare class RMA extends MovingAverage {
86
- readonly interval: number;
87
- private pricesCounter;
88
- private readonly weightFactor;
89
- constructor(interval: number);
90
- getRequiredInputs(): number;
91
- update(price: number, replace: boolean): number;
92
- getResultOrThrow(): number;
93
- get isStable(): boolean;
94
- }
95
-
92
+ #private;
93
+ readonly interval: number;
94
+ constructor(interval: number);
95
+ getRequiredInputs(): number;
96
+ update(price: number, replace: boolean): number;
97
+ getResultOrThrow(): number;
98
+ get isStable(): boolean;
99
+ }
100
+ //#endregion
101
+ //#region src/trend/WMA/WMA.d.ts
96
102
  declare class WMA extends MovingAverage {
97
- readonly interval: number;
98
- readonly prices: number[];
99
- constructor(interval: number);
100
- getRequiredInputs(): number;
101
- update(price: number, replace: boolean): number | null;
102
- }
103
-
103
+ readonly interval: number;
104
+ readonly prices: number[];
105
+ constructor(interval: number);
106
+ getRequiredInputs(): number;
107
+ update(price: number, replace: boolean): number | null;
108
+ }
109
+ //#endregion
110
+ //#region src/trend/WSMA/WSMA.d.ts
104
111
  declare class WSMA extends IndicatorSeries {
105
- readonly interval: number;
106
- private readonly indicator;
107
- private readonly smoothingFactor;
108
- constructor(interval: number);
109
- getRequiredInputs(): number;
110
- update(price: number, replace: boolean): number | null;
111
- }
112
-
112
+ #private;
113
+ readonly interval: number;
114
+ constructor(interval: number);
115
+ getRequiredInputs(): number;
116
+ update(price: number, replace: boolean): number | null;
117
+ }
118
+ //#endregion
119
+ //#region src/trend/MA/MovingAverageTypes.d.ts
113
120
  type MovingAverageTypes = typeof EMA | typeof RMA | typeof SMA | typeof WMA | typeof WSMA;
114
-
121
+ //#endregion
122
+ //#region src/momentum/AO/AO.d.ts
115
123
  declare class AO extends TrendIndicatorSeries<HighLow<number>> {
116
- readonly shortInterval: number;
117
- readonly longInterval: number;
118
- readonly long: MovingAverage;
119
- readonly short: MovingAverage;
120
- constructor(shortInterval: number, longInterval: number, SmoothingIndicator?: MovingAverageTypes);
121
- getRequiredInputs(): number;
122
- update({ low, high }: HighLow<number>, replace: boolean): number | null;
123
- protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
124
- }
125
-
124
+ readonly shortInterval: number;
125
+ readonly longInterval: number;
126
+ readonly long: MovingAverage;
127
+ readonly short: MovingAverage;
128
+ constructor(shortInterval: number, longInterval: number, SmoothingIndicator?: MovingAverageTypes);
129
+ getRequiredInputs(): number;
130
+ update({
131
+ low,
132
+ high
133
+ }: HighLow<number>, replace: boolean): number | null;
134
+ protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
135
+ }
136
+ //#endregion
137
+ //#region src/momentum/MOM/MOM.d.ts
126
138
  declare class MOM extends TrendIndicatorSeries {
127
- readonly interval: number;
128
- private readonly history;
129
- private readonly historyLength;
130
- constructor(interval: number);
131
- getRequiredInputs(): number;
132
- update(value: number, replace: boolean): number | null;
133
- protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
134
- }
135
-
139
+ #private;
140
+ readonly interval: number;
141
+ constructor(interval: number);
142
+ getRequiredInputs(): number;
143
+ update(value: number, replace: boolean): number | null;
144
+ protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
145
+ }
146
+ //#endregion
147
+ //#region src/momentum/AC/AC.d.ts
136
148
  declare class AC extends TrendIndicatorSeries<HighLow<number>> {
137
- readonly shortAO: number;
138
- readonly longAO: number;
139
- readonly signalInterval: number;
140
- readonly ao: AO;
141
- readonly momentum: MOM;
142
- readonly signal: SMA;
143
- constructor(shortAO: number, longAO: number, signalInterval: number);
144
- getRequiredInputs(): number;
145
- update(input: HighLow<number>, replace: boolean): number | null;
146
- protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "UNKNOWN";
147
- }
148
-
149
+ readonly shortAO: number;
150
+ readonly longAO: number;
151
+ readonly signalInterval: number;
152
+ readonly ao: AO;
153
+ readonly momentum: MOM;
154
+ readonly signal: SMA;
155
+ constructor(shortAO: number, longAO: number, signalInterval: number);
156
+ getRequiredInputs(): number;
157
+ update(input: HighLow<number>, replace: boolean): number | null;
158
+ protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "UNKNOWN";
159
+ }
160
+ //#endregion
161
+ //#region src/momentum/CCI/CCI.d.ts
149
162
  declare class CCI extends TrendIndicatorSeries<HighLowClose<number>> {
150
- readonly interval: number;
151
- private readonly sma;
152
- private readonly typicalPrices;
153
- constructor(interval: number);
154
- getRequiredInputs(): number;
155
- update(candle: HighLowClose<number>, replace: boolean): number | null;
156
- private cacheTypicalPrice;
157
- protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
158
- }
159
-
163
+ #private;
164
+ readonly interval: number;
165
+ constructor(interval: number);
166
+ getRequiredInputs(): number;
167
+ update(candle: HighLowClose<number>, replace: boolean): number | null;
168
+ protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
169
+ }
170
+ //#endregion
171
+ //#region src/momentum/CG/CG.d.ts
160
172
  declare class CG extends TrendIndicatorSeries {
161
- readonly interval: number;
162
- readonly signalInterval: number;
163
- signal: SMA;
164
- readonly prices: number[];
165
- get isStable(): boolean;
166
- constructor(interval: number, signalInterval: number);
167
- getRequiredInputs(): number;
168
- protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
169
- update(price: number, replace: boolean): number | null;
170
- }
171
-
173
+ readonly interval: number;
174
+ readonly signalInterval: number;
175
+ signal: SMA;
176
+ readonly prices: number[];
177
+ get isStable(): boolean;
178
+ constructor(interval: number, signalInterval: number);
179
+ getRequiredInputs(): number;
180
+ protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
181
+ update(price: number, replace: boolean): number | null;
182
+ }
183
+ //#endregion
184
+ //#region src/trend/DEMA/DEMA.d.ts
172
185
  declare class DEMA extends IndicatorSeries {
173
- readonly interval: number;
174
- private readonly inner;
175
- private readonly outer;
176
- constructor(interval: number);
177
- getRequiredInputs(): number;
178
- update(price: number, replace: boolean): number;
179
- get isStable(): boolean;
180
- }
181
-
186
+ #private;
187
+ readonly interval: number;
188
+ constructor(interval: number);
189
+ getRequiredInputs(): number;
190
+ update(price: number, replace: boolean): number;
191
+ get isStable(): boolean;
192
+ }
193
+ //#endregion
194
+ //#region src/momentum/MACD/MACD.d.ts
182
195
  type MACDResult = {
196
+ histogram: number;
197
+ macd: number;
198
+ signal: number;
199
+ };
200
+ declare class MACD extends TechnicalIndicator<MACDResult, number> {
201
+ #private;
202
+ readonly short: EMA | DEMA;
203
+ readonly long: EMA | DEMA;
204
+ readonly signal: EMA | DEMA;
205
+ readonly prices: number[];
206
+ constructor(short: EMA | DEMA, long: EMA | DEMA, signal: EMA | DEMA);
207
+ getRequiredInputs(): number;
208
+ update(price: number, replace: boolean): {
183
209
  histogram: number;
184
210
  macd: number;
185
211
  signal: number;
186
- };
187
- declare class MACD extends TechnicalIndicator<MACDResult, number> {
188
- readonly short: EMA | DEMA;
189
- readonly long: EMA | DEMA;
190
- readonly signal: EMA | DEMA;
191
- readonly prices: number[];
192
- private previousResult?;
193
- constructor(short: EMA | DEMA, long: EMA | DEMA, signal: EMA | DEMA);
194
- getRequiredInputs(): number;
195
- update(price: number, replace: boolean): {
196
- histogram: number;
197
- macd: number;
198
- signal: number;
199
- } | null;
200
- protected calculateSignal(result?: MACDResult | null | undefined): "BEARISH" | "BULLISH" | "UNKNOWN";
201
- getSignal(): {
202
- state: (typeof TradingSignal)[keyof typeof TradingSignal];
203
- hasChanged: boolean;
204
- };
205
- }
206
-
212
+ } | null;
213
+ protected calculateSignal(result?: MACDResult | null | undefined): "BEARISH" | "BULLISH" | "UNKNOWN";
214
+ getSignal(): {
215
+ state: (typeof TradingSignal)[keyof typeof TradingSignal];
216
+ hasChanged: boolean;
217
+ };
218
+ }
219
+ //#endregion
220
+ //#region src/momentum/OBV/OBV.d.ts
207
221
  declare class OBV extends TrendIndicatorSeries<OpenHighLowCloseVolume<number>> {
208
- readonly interval: number;
209
- readonly candles: OpenHighLowCloseVolume<number>[];
210
- constructor(interval: number);
211
- getRequiredInputs(): number;
212
- update(candle: OpenHighLowCloseVolume<number>, replace: boolean): number | null;
213
- protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
214
- }
215
-
222
+ readonly interval: number;
223
+ readonly candles: OpenHighLowCloseVolume<number>[];
224
+ constructor(interval: number);
225
+ getRequiredInputs(): number;
226
+ update(candle: OpenHighLowCloseVolume<number>, replace: boolean): number | null;
227
+ protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
228
+ }
229
+ //#endregion
230
+ //#region src/momentum/REI/REI.d.ts
216
231
  declare class REI extends TrendIndicatorSeries<HighLowClose<number>> {
217
- readonly interval: number;
218
- private readonly highs;
219
- private readonly lows;
220
- private readonly closes;
221
- constructor(interval: number);
222
- protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
223
- getRequiredInputs(): number;
224
- private calculateN;
225
- private calculateM;
226
- update(candle: HighLowClose<number>, replace: boolean): number | null;
227
- }
228
-
232
+ #private;
233
+ readonly interval: number;
234
+ constructor(interval: number);
235
+ protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
236
+ getRequiredInputs(): number;
237
+ update(candle: HighLowClose<number>, replace: boolean): number | null;
238
+ }
239
+ //#endregion
240
+ //#region src/momentum/ROC/ROC.d.ts
229
241
  declare class ROC extends TrendIndicatorSeries {
230
- readonly interval: number;
231
- readonly prices: number[];
232
- constructor(interval: number);
233
- getRequiredInputs(): number;
234
- update(price: number, replace: boolean): number | null;
235
- protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "UNKNOWN";
236
- }
237
-
242
+ readonly interval: number;
243
+ readonly prices: number[];
244
+ constructor(interval: number);
245
+ getRequiredInputs(): number;
246
+ update(price: number, replace: boolean): number | null;
247
+ protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "UNKNOWN";
248
+ }
249
+ //#endregion
250
+ //#region src/momentum/RSI/RSI.d.ts
238
251
  declare class RSI extends TrendIndicatorSeries {
239
- readonly interval: number;
240
- private readonly previousPrices;
241
- private readonly avgGain;
242
- private readonly avgLoss;
243
- private readonly maxValue;
244
- constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
245
- getRequiredInputs(): number;
246
- update(price: number, replace: boolean): number | null;
247
- protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
248
- }
249
-
252
+ #private;
253
+ readonly interval: number;
254
+ constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
255
+ getRequiredInputs(): number;
256
+ update(price: number, replace: boolean): number | null;
257
+ protected calculateSignalState(result: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
258
+ }
259
+ //#endregion
260
+ //#region src/momentum/STOCH/StochasticOscillator.d.ts
250
261
  interface StochasticResult {
251
- stochD: number;
252
- stochK: number;
262
+ stochD: number;
263
+ stochK: number;
253
264
  }
254
265
  declare class StochasticOscillator extends TechnicalIndicator<StochasticResult, HighLowClose<number>> {
255
- n: number;
256
- m: number;
257
- p: number;
258
- readonly candles: HighLowClose<number>[];
259
- private readonly periodM;
260
- private readonly periodP;
261
- private previousResult?;
262
- constructor(n: number, m: number, p: number);
263
- getRequiredInputs(): number;
264
- update(candle: HighLowClose<number>, replace: boolean): {
265
- stochD: number;
266
- stochK: number;
267
- } | null;
268
- protected calculateSignal(result?: StochasticResult | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
269
- getSignal(): {
270
- state: (typeof TradingSignal)[keyof typeof TradingSignal];
271
- hasChanged: boolean;
272
- };
273
- }
274
-
266
+ #private;
267
+ n: number;
268
+ m: number;
269
+ p: number;
270
+ readonly candles: HighLowClose<number>[];
271
+ constructor(n: number, m: number, p: number);
272
+ getRequiredInputs(): number;
273
+ update(candle: HighLowClose<number>, replace: boolean): {
274
+ stochD: number;
275
+ stochK: number;
276
+ } | null;
277
+ protected calculateSignal(result?: StochasticResult | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
278
+ getSignal(): {
279
+ state: (typeof TradingSignal)[keyof typeof TradingSignal];
280
+ hasChanged: boolean;
281
+ };
282
+ }
283
+ //#endregion
284
+ //#region src/momentum/STOCHRSI/StochasticRSI.d.ts
275
285
  declare class StochasticRSI extends TrendIndicatorSeries {
276
- readonly interval: number;
277
- readonly smoothing: {
278
- readonly k: MovingAverage;
279
- readonly d: MovingAverage;
280
- };
281
- private readonly period;
282
- private readonly rsi;
283
- constructor(interval: number, SmoothingRSI?: MovingAverageTypes, smoothing?: {
284
- readonly k: MovingAverage;
285
- readonly d: MovingAverage;
286
- });
287
- getRequiredInputs(): number;
288
- update(price: number, replace: boolean): number | null;
289
- protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
290
- }
291
-
286
+ #private;
287
+ readonly interval: number;
288
+ readonly smoothing: {
289
+ readonly k: MovingAverage;
290
+ readonly d: MovingAverage;
291
+ };
292
+ constructor(interval: number, SmoothingRSI?: MovingAverageTypes, smoothing?: {
293
+ readonly k: MovingAverage;
294
+ readonly d: MovingAverage;
295
+ });
296
+ getRequiredInputs(): number;
297
+ update(price: number, replace: boolean): number | null;
298
+ protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
299
+ }
300
+ //#endregion
301
+ //#region src/momentum/TDS/TDS.d.ts
292
302
  declare class TDS extends TrendIndicatorSeries {
293
- private readonly closes;
294
- private setupCount;
295
- private setupDirection;
296
- getRequiredInputs(): number;
297
- update(close: number, replace: boolean): number | null;
298
- protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "UNKNOWN";
299
- }
300
-
303
+ private readonly closes;
304
+ private setupCount;
305
+ private setupDirection;
306
+ getRequiredInputs(): number;
307
+ update(close: number, replace: boolean): number | null;
308
+ protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "UNKNOWN";
309
+ }
310
+ //#endregion
311
+ //#region src/momentum/WILLR/WilliamsR.d.ts
301
312
  declare class WilliamsR extends TrendIndicatorSeries<HighLowClose<number>> {
302
- readonly interval: number;
303
- readonly candles: HighLowClose<number>[];
304
- constructor(interval: number);
305
- getRequiredInputs(): number;
306
- update(candle: HighLowClose<number>, replace: boolean): number | null;
307
- protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
308
- }
309
-
313
+ readonly interval: number;
314
+ readonly candles: HighLowClose<number>[];
315
+ constructor(interval: number);
316
+ getRequiredInputs(): number;
317
+ update(candle: HighLowClose<number>, replace: boolean): number | null;
318
+ protected calculateSignalState(result?: number | null | undefined): "BEARISH" | "BULLISH" | "SIDEWAYS" | "UNKNOWN";
319
+ }
320
+ //#endregion
321
+ //#region src/trend/ADX/ADX.d.ts
310
322
  declare class ADX extends IndicatorSeries<HighLowClose<number>> {
311
- readonly interval: number;
312
- private readonly dx;
313
- private readonly smoothed;
314
- constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
315
- get mdi(): number | void;
316
- get pdi(): number | void;
317
- getRequiredInputs(): number;
318
- update(candle: HighLowClose<number>, replace: boolean): number | null;
319
- }
320
-
323
+ #private;
324
+ readonly interval: number;
325
+ constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
326
+ get mdi(): number | void;
327
+ get pdi(): number | void;
328
+ getRequiredInputs(): number;
329
+ update(candle: HighLowClose<number>, replace: boolean): number | null;
330
+ }
331
+ //#endregion
332
+ //#region src/trend/DMA/DMA.d.ts
321
333
  interface DMAResult {
334
+ long: number;
335
+ short: number;
336
+ }
337
+ declare class DMA extends TechnicalIndicator<DMAResult, number> {
338
+ readonly short: MovingAverage;
339
+ readonly long: MovingAverage;
340
+ constructor(short: number, long: number, SmoothingIndicator?: MovingAverageTypes);
341
+ get isStable(): boolean;
342
+ getRequiredInputs(): number;
343
+ update(price: number, replace: boolean): {
322
344
  long: number;
323
345
  short: number;
346
+ } | null;
324
347
  }
325
- declare class DMA extends TechnicalIndicator<DMAResult, number> {
326
- readonly short: MovingAverage;
327
- readonly long: MovingAverage;
328
- constructor(short: number, long: number, SmoothingIndicator?: MovingAverageTypes);
329
- get isStable(): boolean;
330
- getRequiredInputs(): number;
331
- update(price: number, replace: boolean): {
332
- long: number;
333
- short: number;
334
- } | null;
335
- }
336
-
348
+ //#endregion
349
+ //#region src/trend/DX/DX.d.ts
337
350
  declare class DX extends IndicatorSeries<HighLowClose<number>> {
338
- readonly interval: number;
339
- private readonly movesUp;
340
- private readonly movesDown;
341
- private previousCandle?;
342
- private secondLastCandle?;
343
- private readonly atr;
344
- mdi?: number;
345
- pdi?: number;
346
- constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
347
- private updateState;
348
- getRequiredInputs(): number;
349
- update(candle: HighLowClose<number>, replace: boolean): number | null;
350
- }
351
-
351
+ #private;
352
+ readonly interval: number;
353
+ mdi?: number;
354
+ pdi?: number;
355
+ constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
356
+ getRequiredInputs(): number;
357
+ update(candle: HighLowClose<number>, replace: boolean): number | null;
358
+ }
359
+ //#endregion
360
+ //#region src/trend/LINREG/LinearRegression.d.ts
352
361
  type LinearRegressionResult = {
353
- prediction: number;
354
- slope: number;
355
- intercept: number;
362
+ prediction: number;
363
+ slope: number;
364
+ intercept: number;
356
365
  };
357
366
  declare class LinearRegression extends TechnicalIndicator<LinearRegressionResult, number> {
358
- readonly interval: number;
359
- readonly prices: number[];
360
- constructor(interval: number);
361
- getRequiredInputs(): number;
362
- private calculateRegression;
363
- update(price: number, replace: boolean): LinearRegressionResult | null;
364
- get isStable(): boolean;
365
- }
366
-
367
+ #private;
368
+ readonly interval: number;
369
+ readonly prices: number[];
370
+ constructor(interval: number);
371
+ getRequiredInputs(): number;
372
+ update(price: number, replace: boolean): LinearRegressionResult | null;
373
+ get isStable(): boolean;
374
+ }
375
+ //#endregion
376
+ //#region src/trend/PSAR/PSAR.d.ts
367
377
  type PSARConfig = {
368
- accelerationStep: number;
369
- accelerationMax: number;
378
+ accelerationStep: number;
379
+ accelerationMax: number;
370
380
  };
371
381
  declare class PSAR extends IndicatorSeries<HighLow<number>> {
372
- private readonly accelerationStep;
373
- private readonly accelerationMax;
374
- private acceleration;
375
- private extreme;
376
- private lastSar;
377
- private isLong;
378
- private previousCandle;
379
- private prePreviousCandle;
380
- constructor(config: PSARConfig);
381
- get isStable(): boolean;
382
- getRequiredInputs(): number;
383
- update(candle: HighLow<number>, replace: boolean): number | null;
384
- getResultOrThrow(): number;
385
- }
386
-
382
+ private readonly accelerationStep;
383
+ private readonly accelerationMax;
384
+ private acceleration;
385
+ private extreme;
386
+ private lastSar;
387
+ private isLong;
388
+ private previousCandle;
389
+ private prePreviousCandle;
390
+ constructor(config: PSARConfig);
391
+ get isStable(): boolean;
392
+ getRequiredInputs(): number;
393
+ update(candle: HighLow<number>, replace: boolean): number | null;
394
+ getResultOrThrow(): number;
395
+ }
396
+ //#endregion
397
+ //#region src/trend/SMA15/SMA15.d.ts
387
398
  declare class SMA15 extends MovingAverage {
388
- readonly prices: number[];
389
- private static readonly WEIGHTS;
390
- private static readonly WEIGHT_SUM;
391
- getRequiredInputs(): number;
392
- update(price: number, replace: boolean): number | null;
399
+ #private;
400
+ readonly prices: number[];
401
+ getRequiredInputs(): number;
402
+ update(price: number, replace: boolean): number | null;
393
403
  }
394
-
404
+ //#endregion
405
+ //#region src/trend/VWAP/VWAP.d.ts
395
406
  declare class VWAP extends IndicatorSeries<HighLowCloseVolume<number>> {
396
- private cumulativeTypicalPriceVolume;
397
- private cumulativeVolume;
398
- private lastCandle;
399
- constructor();
400
- private calculateTypicalPriceVolume;
401
- getRequiredInputs(): number;
402
- update(candle: HighLowCloseVolume<number>, replace: boolean): number | null;
403
- }
404
-
407
+ #private;
408
+ constructor();
409
+ getRequiredInputs(): number;
410
+ update(candle: HighLowCloseVolume<number>, replace: boolean): number | null;
411
+ }
412
+ //#endregion
413
+ //#region src/trend/ZIGZAG/ZigZag.d.ts
405
414
  type ZigZagConfig = {
406
- deviation: number;
415
+ deviation: number;
407
416
  };
408
417
  declare class ZigZag extends IndicatorSeries<HighLow> {
409
- private readonly deviation;
410
- private isUp;
411
- private highestExtreme;
412
- private lowestExtreme;
413
- constructor(config: ZigZagConfig);
414
- getRequiredInputs(): number;
415
- update(candle: HighLow<number>, replace: boolean): number | null;
416
- }
417
-
418
+ #private;
419
+ constructor(config: ZigZagConfig);
420
+ getRequiredInputs(): number;
421
+ update(candle: HighLow<number>, replace: boolean): number | null;
422
+ }
423
+ //#endregion
424
+ //#region src/types/BandsResult.d.ts
418
425
  interface BandsResult {
419
- lower: number;
420
- middle: number;
421
- upper: number;
426
+ lower: number;
427
+ middle: number;
428
+ upper: number;
422
429
  }
423
-
430
+ //#endregion
431
+ //#region src/types/Period.d.ts
424
432
  interface PeriodResult {
433
+ highest: number;
434
+ lowest: number;
435
+ }
436
+ declare class Period extends TechnicalIndicator<PeriodResult, number> {
437
+ #private;
438
+ readonly interval: number;
439
+ values: number[];
440
+ get highest(): number | undefined;
441
+ get lowest(): number | undefined;
442
+ constructor(interval: number);
443
+ getRequiredInputs(): number;
444
+ update(value: number, replace: boolean): {
425
445
  highest: number;
426
446
  lowest: number;
447
+ } | null;
427
448
  }
428
- declare class Period extends TechnicalIndicator<PeriodResult, number> {
429
- readonly interval: number;
430
- values: number[];
431
- private _highest?;
432
- private _lowest?;
433
- get highest(): number | undefined;
434
- get lowest(): number | undefined;
435
- constructor(interval: number);
436
- getRequiredInputs(): number;
437
- update(value: number, replace: boolean): {
438
- highest: number;
439
- lowest: number;
440
- } | null;
441
- }
442
-
449
+ //#endregion
450
+ //#region src/util/getAverage.d.ts
443
451
  declare function getAverage(values: number[]): number;
444
-
452
+ //#endregion
453
+ //#region src/util/getGrid.d.ts
445
454
  type GridConfig = {
446
- lower: number;
447
- upper: number;
448
- levels: number;
449
- spacing: 'arithmetic' | 'geometric';
450
- tickSize?: number;
455
+ lower: number;
456
+ upper: number;
457
+ levels: number;
458
+ spacing: 'arithmetic' | 'geometric';
459
+ tickSize?: number;
451
460
  };
452
- declare function getGrid({ lower, upper, levels, tickSize, spacing }: GridConfig): number[];
453
-
461
+ declare function getGrid({
462
+ lower,
463
+ upper,
464
+ levels,
465
+ tickSize,
466
+ spacing
467
+ }: GridConfig): number[];
468
+ //#endregion
469
+ //#region src/util/getMaximum.d.ts
454
470
  declare function getMaximum(values: number[]): number;
455
-
471
+ //#endregion
472
+ //#region src/util/getMedian.d.ts
456
473
  declare function getMedian(values: number[]): number;
457
-
474
+ //#endregion
475
+ //#region src/util/getMinimum.d.ts
458
476
  declare function getMinimum(values: number[]): number;
459
-
477
+ //#endregion
478
+ //#region src/util/getQuartile.d.ts
460
479
  declare function getQuartile(values: number[], q: 0.25 | 0.5 | 0.75): number;
461
-
480
+ //#endregion
481
+ //#region src/util/getStandardDeviation.d.ts
462
482
  declare function getStandardDeviation(values: number[], average?: number): number;
463
-
483
+ //#endregion
484
+ //#region src/util/getStreaks.d.ts
464
485
  type Streak = {
465
- length: number;
466
- percentage: number;
486
+ length: number;
487
+ percentage: number;
467
488
  };
468
489
  declare function getStreaks(prices: number[], keepSide: 'up' | 'down'): Streak[];
469
-
490
+ //#endregion
491
+ //#region src/util/getWeekday.d.ts
470
492
  declare function isMonday(timezone: string, date?: Date): boolean;
471
493
  declare function isTuesday(timezone: string, date?: Date): boolean;
472
494
  declare function isWednesday(timezone: string, date?: Date): boolean;
@@ -474,76 +496,84 @@ declare function isThursday(timezone: string, date?: Date): boolean;
474
496
  declare function isFriday(timezone: string, date?: Date): boolean;
475
497
  declare function isSaturday(timezone: string, date?: Date): boolean;
476
498
  declare function isSunday(timezone: string, date?: Date): boolean;
477
-
499
+ //#endregion
500
+ //#region src/util/pushUpdate.d.ts
478
501
  declare function pushUpdate<T>(array: T[], replace: boolean, item: T, maxLength: number): T | null | undefined;
479
-
502
+ //#endregion
503
+ //#region src/volatility/ABANDS/AccelerationBands.d.ts
480
504
  declare class AccelerationBands extends TechnicalIndicator<BandsResult, HighLowClose<number>> {
481
- readonly interval: number;
482
- readonly width: number;
483
- private readonly lowerBand;
484
- private readonly middleBand;
485
- private readonly upperBand;
486
- constructor(interval: number, width: number, SmoothingIndicator?: MovingAverageTypes);
487
- getRequiredInputs(): number;
488
- update({ high, low, close }: HighLowClose<number>, replace: boolean): {
489
- lower: number;
490
- middle: number;
491
- upper: number;
492
- } | null;
493
- get isStable(): boolean;
494
- }
495
-
505
+ #private;
506
+ readonly interval: number;
507
+ readonly width: number;
508
+ constructor(interval: number, width: number, SmoothingIndicator?: MovingAverageTypes);
509
+ getRequiredInputs(): number;
510
+ update({
511
+ high,
512
+ low,
513
+ close
514
+ }: HighLowClose<number>, replace: boolean): {
515
+ lower: number;
516
+ middle: number;
517
+ upper: number;
518
+ } | null;
519
+ get isStable(): boolean;
520
+ }
521
+ //#endregion
522
+ //#region src/volatility/ATR/ATR.d.ts
496
523
  declare class ATR extends IndicatorSeries<HighLowClose<number>> {
497
- readonly interval: number;
498
- private readonly tr;
499
- private readonly smoothing;
500
- constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
501
- getRequiredInputs(): number;
502
- update(candle: HighLowClose<number>, replace: boolean): number | null;
503
- }
504
-
524
+ #private;
525
+ readonly interval: number;
526
+ constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
527
+ getRequiredInputs(): number;
528
+ update(candle: HighLowClose<number>, replace: boolean): number | null;
529
+ }
530
+ //#endregion
531
+ //#region src/volatility/BBANDS/BollingerBands.d.ts
505
532
  declare class BollingerBands extends TechnicalIndicator<BandsResult, number> {
506
- readonly interval: number;
507
- readonly deviationMultiplier: number;
508
- readonly prices: number[];
509
- constructor(interval: number, deviationMultiplier?: number);
510
- getRequiredInputs(): number;
511
- update(price: number, replace: boolean): {
512
- lower: number;
513
- middle: number;
514
- upper: number;
515
- } | null;
516
- }
517
-
533
+ readonly interval: number;
534
+ readonly deviationMultiplier: number;
535
+ readonly prices: number[];
536
+ constructor(interval: number, deviationMultiplier?: number);
537
+ getRequiredInputs(): number;
538
+ update(price: number, replace: boolean): {
539
+ lower: number;
540
+ middle: number;
541
+ upper: number;
542
+ } | null;
543
+ }
544
+ //#endregion
545
+ //#region src/volatility/BBW/BollingerBandsWidth.d.ts
518
546
  declare class BollingerBandsWidth extends IndicatorSeries {
519
- readonly bollingerBands: BollingerBands;
520
- constructor(bollingerBands: BollingerBands);
521
- getRequiredInputs(): number;
522
- update(price: number, replace: boolean): number | null;
547
+ readonly bollingerBands: BollingerBands;
548
+ constructor(bollingerBands: BollingerBands);
549
+ getRequiredInputs(): number;
550
+ update(price: number, replace: boolean): number | null;
523
551
  }
524
-
552
+ //#endregion
553
+ //#region src/volatility/IQR/IQR.d.ts
525
554
  declare class IQR extends IndicatorSeries {
526
- readonly interval: number;
527
- private readonly values;
528
- constructor(interval: number);
529
- getRequiredInputs(): number;
530
- update(value: number, replace: boolean): number | null;
531
- }
532
-
555
+ #private;
556
+ readonly interval: number;
557
+ constructor(interval: number);
558
+ getRequiredInputs(): number;
559
+ update(value: number, replace: boolean): number | null;
560
+ }
561
+ //#endregion
562
+ //#region src/volatility/MAD/MAD.d.ts
533
563
  declare class MAD extends IndicatorSeries {
534
- readonly interval: number;
535
- readonly prices: number[];
536
- constructor(interval: number);
537
- getRequiredInputs(): number;
538
- update(price: number, replace: boolean): number | null;
539
- static getResultFromBatch(prices: number[], average?: number): number;
540
- }
541
-
564
+ readonly interval: number;
565
+ readonly prices: number[];
566
+ constructor(interval: number);
567
+ getRequiredInputs(): number;
568
+ update(price: number, replace: boolean): number | null;
569
+ static getResultFromBatch(prices: number[], average?: number): number;
570
+ }
571
+ //#endregion
572
+ //#region src/volatility/TR/TR.d.ts
542
573
  declare class TR extends IndicatorSeries<HighLowClose<number>> {
543
- private previousCandle?;
544
- private twoPreviousCandle?;
545
- getRequiredInputs(): number;
546
- update(candle: HighLowClose<number>, replace: boolean): number;
574
+ #private;
575
+ getRequiredInputs(): number;
576
+ update(candle: HighLowClose<number>, replace: boolean): number;
547
577
  }
548
-
549
- export { AC, ADX, AO, ATR, AccelerationBands, type BandsResult, BollingerBands, BollingerBandsWidth, CCI, CG, DEMA, DMA, type DMAResult, DX, EMA, type GridConfig, type HighLow, type HighLowClose, type HighLowCloseVolume, IQR, IndicatorSeries, LinearRegression, type LinearRegressionResult, MACD, type MACDResult, MAD, MOM, NotEnoughDataError, OBV, type OpenHighLowClose, type OpenHighLowCloseVolume, PSAR, type PSARConfig, Period, type PeriodResult, REI, RMA, ROC, RSI, SMA, SMA15, StochasticOscillator, StochasticRSI, type StochasticResult, type Streak, TDS, TR, TechnicalIndicator, TradingSignal, type TradingSignals, TrendIndicatorSeries, VWAP, WMA, WSMA, WilliamsR, ZigZag, type ZigZagConfig, getAverage, getGrid, getMaximum, getMedian, getMinimum, getQuartile, getStandardDeviation, getStreaks, isFriday, isMonday, isSaturday, isSunday, isThursday, isTuesday, isWednesday, pushUpdate };
578
+ //#endregion
579
+ export { AC, ADX, AO, ATR, AccelerationBands, BandsResult, BollingerBands, BollingerBandsWidth, CCI, CG, DEMA, DMA, DMAResult, DX, EMA, GridConfig, HighLow, HighLowClose, HighLowCloseVolume, IQR, IndicatorSeries, LinearRegression, LinearRegressionResult, MACD, MACDResult, MAD, MOM, NotEnoughDataError, OBV, OpenHighLowClose, OpenHighLowCloseVolume, PSAR, PSARConfig, Period, PeriodResult, REI, RMA, ROC, RSI, SMA, SMA15, StochasticOscillator, StochasticRSI, StochasticResult, Streak, TDS, TR, TechnicalIndicator, TradingSignal, TradingSignals, TrendIndicatorSeries, VWAP, WMA, WSMA, WilliamsR, ZigZag, ZigZagConfig, getAverage, getGrid, getMaximum, getMedian, getMinimum, getQuartile, getStandardDeviation, getStreaks, isFriday, isMonday, isSaturday, isSunday, isThursday, isTuesday, isWednesday, pushUpdate };