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/README.md +1 -1
- package/dist/index.cjs +1966 -1727
- package/dist/index.d.cts +476 -446
- package/dist/index.d.mts +579 -0
- package/dist/index.mjs +2074 -0
- package/package.json +15 -11
- package/dist/index.d.ts +0 -549
- package/dist/index.js +0 -1809
package/dist/index.d.mts
ADDED
|
@@ -0,0 +1,579 @@
|
|
|
1
|
+
//#region src/error/NotEnoughDataError.d.ts
|
|
2
|
+
declare class NotEnoughDataError extends Error {
|
|
3
|
+
constructor(requiredAmount: number);
|
|
4
|
+
}
|
|
5
|
+
//#endregion
|
|
6
|
+
//#region src/types/Indicator.d.ts
|
|
7
|
+
type Nullable<Result> = Result | null;
|
|
8
|
+
interface Indicator<Result = number, Input = number> {
|
|
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>[];
|
|
17
|
+
}
|
|
18
|
+
declare const TradingSignal: {
|
|
19
|
+
readonly BEARISH: "BEARISH";
|
|
20
|
+
readonly BULLISH: "BULLISH";
|
|
21
|
+
readonly SIDEWAYS: "SIDEWAYS";
|
|
22
|
+
readonly UNKNOWN: "UNKNOWN";
|
|
23
|
+
};
|
|
24
|
+
type TradingSignals = (typeof TradingSignal)[keyof typeof TradingSignal];
|
|
25
|
+
declare abstract class TechnicalIndicator<Result, Input> implements Indicator<Result, Input> {
|
|
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)[];
|
|
35
|
+
}
|
|
36
|
+
declare abstract class IndicatorSeries<Input = number> extends TechnicalIndicator<number, Input> {
|
|
37
|
+
protected previousResult?: number;
|
|
38
|
+
protected setResult(value: number, replace: boolean): number;
|
|
39
|
+
}
|
|
40
|
+
declare abstract class TrendIndicatorSeries<Input = number, SignalState = TradingSignals> extends IndicatorSeries<Input> {
|
|
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
|
|
51
|
+
declare abstract class MovingAverage extends IndicatorSeries {
|
|
52
|
+
readonly interval: number;
|
|
53
|
+
constructor(interval: number);
|
|
54
|
+
}
|
|
55
|
+
//#endregion
|
|
56
|
+
//#region src/trend/SMA/SMA.d.ts
|
|
57
|
+
declare class SMA extends MovingAverage {
|
|
58
|
+
readonly prices: number[];
|
|
59
|
+
getRequiredInputs(): number;
|
|
60
|
+
update(price: number, replace: boolean): number | null;
|
|
61
|
+
}
|
|
62
|
+
//#endregion
|
|
63
|
+
//#region src/types/HighLowClose.d.ts
|
|
64
|
+
type HighLow<T = number> = {
|
|
65
|
+
high: T;
|
|
66
|
+
low: T;
|
|
67
|
+
};
|
|
68
|
+
type HighLowClose<T = number> = HighLow<T> & {
|
|
69
|
+
close: T;
|
|
70
|
+
};
|
|
71
|
+
type OpenHighLowClose<T = number> = HighLowClose<T> & {
|
|
72
|
+
open: T;
|
|
73
|
+
};
|
|
74
|
+
type OpenHighLowCloseVolume<T = number> = OpenHighLowClose<T> & {
|
|
75
|
+
volume: T;
|
|
76
|
+
};
|
|
77
|
+
type HighLowCloseVolume<T = number> = Omit<OpenHighLowCloseVolume<T>, 'open'>;
|
|
78
|
+
//#endregion
|
|
79
|
+
//#region src/trend/EMA/EMA.d.ts
|
|
80
|
+
declare class EMA extends MovingAverage {
|
|
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
|
|
91
|
+
declare class RMA extends MovingAverage {
|
|
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
|
|
102
|
+
declare class WMA extends MovingAverage {
|
|
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
|
|
111
|
+
declare class WSMA extends IndicatorSeries {
|
|
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
|
|
120
|
+
type MovingAverageTypes = typeof EMA | typeof RMA | typeof SMA | typeof WMA | typeof WSMA;
|
|
121
|
+
//#endregion
|
|
122
|
+
//#region src/momentum/AO/AO.d.ts
|
|
123
|
+
declare class AO extends TrendIndicatorSeries<HighLow<number>> {
|
|
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
|
|
138
|
+
declare class MOM extends TrendIndicatorSeries {
|
|
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
|
|
148
|
+
declare class AC extends TrendIndicatorSeries<HighLow<number>> {
|
|
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
|
|
162
|
+
declare class CCI extends TrendIndicatorSeries<HighLowClose<number>> {
|
|
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
|
|
172
|
+
declare class CG extends TrendIndicatorSeries {
|
|
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
|
|
185
|
+
declare class DEMA extends IndicatorSeries {
|
|
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
|
|
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): {
|
|
209
|
+
histogram: number;
|
|
210
|
+
macd: number;
|
|
211
|
+
signal: number;
|
|
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
|
|
221
|
+
declare class OBV extends TrendIndicatorSeries<OpenHighLowCloseVolume<number>> {
|
|
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
|
|
231
|
+
declare class REI extends TrendIndicatorSeries<HighLowClose<number>> {
|
|
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
|
|
241
|
+
declare class ROC extends TrendIndicatorSeries {
|
|
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
|
|
251
|
+
declare class RSI extends TrendIndicatorSeries {
|
|
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
|
|
261
|
+
interface StochasticResult {
|
|
262
|
+
stochD: number;
|
|
263
|
+
stochK: number;
|
|
264
|
+
}
|
|
265
|
+
declare class StochasticOscillator extends TechnicalIndicator<StochasticResult, HighLowClose<number>> {
|
|
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
|
|
285
|
+
declare class StochasticRSI extends TrendIndicatorSeries {
|
|
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
|
|
302
|
+
declare class TDS extends TrendIndicatorSeries {
|
|
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
|
|
312
|
+
declare class WilliamsR extends TrendIndicatorSeries<HighLowClose<number>> {
|
|
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
|
|
322
|
+
declare class ADX extends IndicatorSeries<HighLowClose<number>> {
|
|
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
|
|
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): {
|
|
344
|
+
long: number;
|
|
345
|
+
short: number;
|
|
346
|
+
} | null;
|
|
347
|
+
}
|
|
348
|
+
//#endregion
|
|
349
|
+
//#region src/trend/DX/DX.d.ts
|
|
350
|
+
declare class DX extends IndicatorSeries<HighLowClose<number>> {
|
|
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
|
|
361
|
+
type LinearRegressionResult = {
|
|
362
|
+
prediction: number;
|
|
363
|
+
slope: number;
|
|
364
|
+
intercept: number;
|
|
365
|
+
};
|
|
366
|
+
declare class LinearRegression extends TechnicalIndicator<LinearRegressionResult, number> {
|
|
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
|
|
377
|
+
type PSARConfig = {
|
|
378
|
+
accelerationStep: number;
|
|
379
|
+
accelerationMax: number;
|
|
380
|
+
};
|
|
381
|
+
declare class PSAR extends IndicatorSeries<HighLow<number>> {
|
|
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
|
|
398
|
+
declare class SMA15 extends MovingAverage {
|
|
399
|
+
#private;
|
|
400
|
+
readonly prices: number[];
|
|
401
|
+
getRequiredInputs(): number;
|
|
402
|
+
update(price: number, replace: boolean): number | null;
|
|
403
|
+
}
|
|
404
|
+
//#endregion
|
|
405
|
+
//#region src/trend/VWAP/VWAP.d.ts
|
|
406
|
+
declare class VWAP extends IndicatorSeries<HighLowCloseVolume<number>> {
|
|
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
|
|
414
|
+
type ZigZagConfig = {
|
|
415
|
+
deviation: number;
|
|
416
|
+
};
|
|
417
|
+
declare class ZigZag extends IndicatorSeries<HighLow> {
|
|
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
|
|
425
|
+
interface BandsResult {
|
|
426
|
+
lower: number;
|
|
427
|
+
middle: number;
|
|
428
|
+
upper: number;
|
|
429
|
+
}
|
|
430
|
+
//#endregion
|
|
431
|
+
//#region src/types/Period.d.ts
|
|
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): {
|
|
445
|
+
highest: number;
|
|
446
|
+
lowest: number;
|
|
447
|
+
} | null;
|
|
448
|
+
}
|
|
449
|
+
//#endregion
|
|
450
|
+
//#region src/util/getAverage.d.ts
|
|
451
|
+
declare function getAverage(values: number[]): number;
|
|
452
|
+
//#endregion
|
|
453
|
+
//#region src/util/getGrid.d.ts
|
|
454
|
+
type GridConfig = {
|
|
455
|
+
lower: number;
|
|
456
|
+
upper: number;
|
|
457
|
+
levels: number;
|
|
458
|
+
spacing: 'arithmetic' | 'geometric';
|
|
459
|
+
tickSize?: number;
|
|
460
|
+
};
|
|
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
|
|
470
|
+
declare function getMaximum(values: number[]): number;
|
|
471
|
+
//#endregion
|
|
472
|
+
//#region src/util/getMedian.d.ts
|
|
473
|
+
declare function getMedian(values: number[]): number;
|
|
474
|
+
//#endregion
|
|
475
|
+
//#region src/util/getMinimum.d.ts
|
|
476
|
+
declare function getMinimum(values: number[]): number;
|
|
477
|
+
//#endregion
|
|
478
|
+
//#region src/util/getQuartile.d.ts
|
|
479
|
+
declare function getQuartile(values: number[], q: 0.25 | 0.5 | 0.75): number;
|
|
480
|
+
//#endregion
|
|
481
|
+
//#region src/util/getStandardDeviation.d.ts
|
|
482
|
+
declare function getStandardDeviation(values: number[], average?: number): number;
|
|
483
|
+
//#endregion
|
|
484
|
+
//#region src/util/getStreaks.d.ts
|
|
485
|
+
type Streak = {
|
|
486
|
+
length: number;
|
|
487
|
+
percentage: number;
|
|
488
|
+
};
|
|
489
|
+
declare function getStreaks(prices: number[], keepSide: 'up' | 'down'): Streak[];
|
|
490
|
+
//#endregion
|
|
491
|
+
//#region src/util/getWeekday.d.ts
|
|
492
|
+
declare function isMonday(timezone: string, date?: Date): boolean;
|
|
493
|
+
declare function isTuesday(timezone: string, date?: Date): boolean;
|
|
494
|
+
declare function isWednesday(timezone: string, date?: Date): boolean;
|
|
495
|
+
declare function isThursday(timezone: string, date?: Date): boolean;
|
|
496
|
+
declare function isFriday(timezone: string, date?: Date): boolean;
|
|
497
|
+
declare function isSaturday(timezone: string, date?: Date): boolean;
|
|
498
|
+
declare function isSunday(timezone: string, date?: Date): boolean;
|
|
499
|
+
//#endregion
|
|
500
|
+
//#region src/util/pushUpdate.d.ts
|
|
501
|
+
declare function pushUpdate<T>(array: T[], replace: boolean, item: T, maxLength: number): T | null | undefined;
|
|
502
|
+
//#endregion
|
|
503
|
+
//#region src/volatility/ABANDS/AccelerationBands.d.ts
|
|
504
|
+
declare class AccelerationBands extends TechnicalIndicator<BandsResult, HighLowClose<number>> {
|
|
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
|
|
523
|
+
declare class ATR extends IndicatorSeries<HighLowClose<number>> {
|
|
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
|
|
532
|
+
declare class BollingerBands extends TechnicalIndicator<BandsResult, number> {
|
|
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
|
|
546
|
+
declare class BollingerBandsWidth extends IndicatorSeries {
|
|
547
|
+
readonly bollingerBands: BollingerBands;
|
|
548
|
+
constructor(bollingerBands: BollingerBands);
|
|
549
|
+
getRequiredInputs(): number;
|
|
550
|
+
update(price: number, replace: boolean): number | null;
|
|
551
|
+
}
|
|
552
|
+
//#endregion
|
|
553
|
+
//#region src/volatility/IQR/IQR.d.ts
|
|
554
|
+
declare class IQR extends IndicatorSeries {
|
|
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
|
|
563
|
+
declare class MAD extends IndicatorSeries {
|
|
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
|
|
573
|
+
declare class TR extends IndicatorSeries<HighLowClose<number>> {
|
|
574
|
+
#private;
|
|
575
|
+
getRequiredInputs(): number;
|
|
576
|
+
update(candle: HighLowClose<number>, replace: boolean): number;
|
|
577
|
+
}
|
|
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 };
|