trading-signals 7.2.0 → 7.4.2

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/package.json CHANGED
@@ -4,15 +4,19 @@
4
4
  },
5
5
  "description": "Technical indicators to run technical analysis with JavaScript / TypeScript.",
6
6
  "devDependencies": {
7
- "@arethetypeswrong/cli": "^0.18.2",
8
- "dependency-cruiser": "^17.3.2",
9
7
  "generate-changelog": "^1.8.0",
10
- "tsup": "^8.5.1"
8
+ "tsdown": "^0.17.4"
11
9
  },
12
10
  "exports": {
13
11
  ".": {
14
- "import": "./dist/index.js",
15
- "require": "./dist/index.cjs"
12
+ "import": {
13
+ "types": "./dist/index.d.mts",
14
+ "default": "./dist/index.mjs"
15
+ },
16
+ "require": {
17
+ "types": "./dist/index.d.cts",
18
+ "default": "./dist/index.cjs"
19
+ }
16
20
  },
17
21
  "./package.json": "./package.json"
18
22
  },
@@ -57,10 +61,10 @@
57
61
  "url": "git+https://github.com/bennycode/trading-signals.git"
58
62
  },
59
63
  "scripts": {
60
- "build": "tsup",
64
+ "build": "tsdown --dts --format esm --format cjs",
61
65
  "changelog:commit": "git add CHANGELOG.md && git commit -m \"docs: updated CHANGELOG.md\"",
62
66
  "clean": "rimraf coverage dist",
63
- "dist": "npm run clean && npm run build",
67
+ "dist": "npm run clean && npm run build && npm run test:exports",
64
68
  "fix": "npm run fix:other && npm run fix:code",
65
69
  "fix:code": "npm run lint:code -- --fix",
66
70
  "fix:other": "npm run prettier -- --write",
@@ -70,18 +74,18 @@
70
74
  "lint:types": "tsc --noEmit",
71
75
  "postversion": "git push origin && git push origin --tags && npm publish && git restore .",
72
76
  "prettier": "prettier --config ../../.prettierrc.json --ignore-path ../../.gitignore --log-level error \"**/*.{json,scss,yml}\"",
73
- "preversion": "git checkout main && git pull && npm install && npm run test && npm run dist && npm run test:exports",
77
+ "preversion": "npm run test && npm run dist",
74
78
  "release:major": "generate-changelog -M -x \"chore,test\" && npm run changelog:commit && npm version major",
75
79
  "release:minor": "generate-changelog -m -x \"chore,test\" && npm run changelog:commit && npm version minor",
76
80
  "release:patch": "generate-changelog -p -x \"chore,test\" && npm run changelog:commit && npm version patch",
77
81
  "start": "tsx ./src/start/demo.ts",
78
82
  "test": "npm run test:types && npm run test:imports && npm run test:units -- --coverage",
79
- "test:exports": "attw --pack .",
80
- "test:imports": "depcruise src --include-only \"^src\"",
83
+ "test:exports": "attw --pack . --profile node16",
84
+ "test:imports": "depcruise -c ../../.dependency-cruiser.cjs src --include-only \"^src\"",
81
85
  "test:types": "npm run lint:types",
82
86
  "test:units": "vitest run --passWithNoTests",
83
87
  "test:units:watch": "vitest --watch"
84
88
  },
85
89
  "type": "module",
86
- "version": "7.2.0"
90
+ "version": "7.4.2"
87
91
  }
package/dist/index.d.ts DELETED
@@ -1,549 +0,0 @@
1
- declare class NotEnoughDataError extends Error {
2
- constructor(requiredAmount: number);
3
- }
4
-
5
- type Nullable<Result> = Result | null;
6
- 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>[];
15
- }
16
- declare const TradingSignal: {
17
- readonly BEARISH: "BEARISH";
18
- readonly BULLISH: "BULLISH";
19
- readonly SIDEWAYS: "SIDEWAYS";
20
- readonly UNKNOWN: "UNKNOWN";
21
- };
22
- type TradingSignals = (typeof TradingSignal)[keyof typeof TradingSignal];
23
- 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)[];
33
- }
34
- declare abstract class IndicatorSeries<Input = number> extends TechnicalIndicator<number, Input> {
35
- protected previousResult?: number;
36
- protected setResult(value: number, replace: boolean): number;
37
- }
38
- 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
-
48
- declare abstract class MovingAverage extends IndicatorSeries {
49
- readonly interval: number;
50
- constructor(interval: number);
51
- }
52
-
53
- declare class SMA extends MovingAverage {
54
- readonly prices: number[];
55
- getRequiredInputs(): number;
56
- update(price: number, replace: boolean): number | null;
57
- }
58
-
59
- type HighLow<T = number> = {
60
- high: T;
61
- low: T;
62
- };
63
- type HighLowClose<T = number> = HighLow<T> & {
64
- close: T;
65
- };
66
- type OpenHighLowClose<T = number> = HighLowClose<T> & {
67
- open: T;
68
- };
69
- type OpenHighLowCloseVolume<T = number> = OpenHighLowClose<T> & {
70
- volume: T;
71
- };
72
- type HighLowCloseVolume<T = number> = Omit<OpenHighLowCloseVolume<T>, 'open'>;
73
-
74
- 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
-
85
- 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
-
96
- 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
-
104
- 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
-
113
- type MovingAverageTypes = typeof EMA | typeof RMA | typeof SMA | typeof WMA | typeof WSMA;
114
-
115
- 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
-
126
- 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
-
136
- 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
- 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
-
160
- 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
-
172
- 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
-
182
- type MACDResult = {
183
- histogram: number;
184
- macd: number;
185
- 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
-
207
- 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
-
216
- 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
-
229
- 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
-
238
- 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
-
250
- interface StochasticResult {
251
- stochD: number;
252
- stochK: number;
253
- }
254
- 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
-
275
- 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
-
292
- 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
-
301
- 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
-
310
- 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
-
321
- interface DMAResult {
322
- long: number;
323
- short: number;
324
- }
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
-
337
- 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
-
352
- type LinearRegressionResult = {
353
- prediction: number;
354
- slope: number;
355
- intercept: number;
356
- };
357
- 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
- type PSARConfig = {
368
- accelerationStep: number;
369
- accelerationMax: number;
370
- };
371
- 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
-
387
- 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;
393
- }
394
-
395
- 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
-
405
- type ZigZagConfig = {
406
- deviation: number;
407
- };
408
- 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
- interface BandsResult {
419
- lower: number;
420
- middle: number;
421
- upper: number;
422
- }
423
-
424
- interface PeriodResult {
425
- highest: number;
426
- lowest: number;
427
- }
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
-
443
- declare function getAverage(values: number[]): number;
444
-
445
- type GridConfig = {
446
- lower: number;
447
- upper: number;
448
- levels: number;
449
- spacing: 'arithmetic' | 'geometric';
450
- tickSize?: number;
451
- };
452
- declare function getGrid({ lower, upper, levels, tickSize, spacing }: GridConfig): number[];
453
-
454
- declare function getMaximum(values: number[]): number;
455
-
456
- declare function getMedian(values: number[]): number;
457
-
458
- declare function getMinimum(values: number[]): number;
459
-
460
- declare function getQuartile(values: number[], q: 0.25 | 0.5 | 0.75): number;
461
-
462
- declare function getStandardDeviation(values: number[], average?: number): number;
463
-
464
- type Streak = {
465
- length: number;
466
- percentage: number;
467
- };
468
- declare function getStreaks(prices: number[], keepSide: 'up' | 'down'): Streak[];
469
-
470
- declare function isMonday(timezone: string, date?: Date): boolean;
471
- declare function isTuesday(timezone: string, date?: Date): boolean;
472
- declare function isWednesday(timezone: string, date?: Date): boolean;
473
- declare function isThursday(timezone: string, date?: Date): boolean;
474
- declare function isFriday(timezone: string, date?: Date): boolean;
475
- declare function isSaturday(timezone: string, date?: Date): boolean;
476
- declare function isSunday(timezone: string, date?: Date): boolean;
477
-
478
- declare function pushUpdate<T>(array: T[], replace: boolean, item: T, maxLength: number): T | null | undefined;
479
-
480
- 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
-
496
- 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
-
505
- 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
-
518
- declare class BollingerBandsWidth extends IndicatorSeries {
519
- readonly bollingerBands: BollingerBands;
520
- constructor(bollingerBands: BollingerBands);
521
- getRequiredInputs(): number;
522
- update(price: number, replace: boolean): number | null;
523
- }
524
-
525
- 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
-
533
- 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
-
542
- declare class TR extends IndicatorSeries<HighLowClose<number>> {
543
- private previousCandle?;
544
- private twoPreviousCandle?;
545
- getRequiredInputs(): number;
546
- update(candle: HighLowClose<number>, replace: boolean): number;
547
- }
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 };