@cadenza.io/service 1.1.1 → 1.2.0
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.mts +651 -260
- package/dist/index.d.ts +651 -260
- package/dist/index.js +5 -2
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +4 -2
- package/dist/index.mjs.map +1 -1
- package/package.json +2 -3
package/dist/index.d.mts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import * as _cadenza_io_core from '@cadenza.io/core';
|
|
2
2
|
import { Task, ThrottleTagGetter, SchemaDefinition, GraphContext, AnyObject, TaskResult, SignalBroker, GraphRunner, GraphRegistry, CadenzaMode, TaskOptions, TaskFunction, DebounceOptions, DebounceTask, EphemeralTaskOptions, EphemeralTask, GraphRoutine } from '@cadenza.io/core';
|
|
3
|
+
export { AnyObject } from '@cadenza.io/core';
|
|
3
4
|
|
|
4
5
|
declare class DeputyTask extends Task {
|
|
5
6
|
readonly isDeputy: boolean;
|
|
@@ -291,12 +292,15 @@ declare class CadenzaService {
|
|
|
291
292
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
292
293
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
293
294
|
onProgress(progress: number): void;
|
|
294
|
-
postProcess():
|
|
295
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
296
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
297
|
+
finalize(): void;
|
|
295
298
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
296
299
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
297
300
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
298
301
|
delayRetry(): Promise<void>;
|
|
299
|
-
divide(): /*elided*/ any[]
|
|
302
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
303
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
300
304
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
301
305
|
differentiate(task: Task): /*elided*/ any;
|
|
302
306
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -428,12 +432,15 @@ declare class CadenzaService {
|
|
|
428
432
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
429
433
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
430
434
|
onProgress(progress: number): void;
|
|
431
|
-
postProcess():
|
|
435
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
436
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
437
|
+
finalize(): void;
|
|
432
438
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
433
439
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
434
440
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
435
441
|
delayRetry(): Promise<void>;
|
|
436
|
-
divide(): /*elided*/ any[]
|
|
442
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
443
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
437
444
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
438
445
|
differentiate(task: Task): /*elided*/ any;
|
|
439
446
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -558,12 +565,15 @@ declare class CadenzaService {
|
|
|
558
565
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
559
566
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
560
567
|
onProgress(progress: number): void;
|
|
561
|
-
postProcess():
|
|
568
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
569
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
570
|
+
finalize(): void;
|
|
562
571
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
563
572
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
564
573
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
565
574
|
delayRetry(): Promise<void>;
|
|
566
|
-
divide(): /*elided*/ any[]
|
|
575
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
576
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
567
577
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
568
578
|
differentiate(task: Task): /*elided*/ any;
|
|
569
579
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -687,12 +697,15 @@ declare class CadenzaService {
|
|
|
687
697
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
688
698
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
689
699
|
onProgress(progress: number): void;
|
|
690
|
-
postProcess():
|
|
700
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
701
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
702
|
+
finalize(): void;
|
|
691
703
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
692
704
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
693
705
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
694
706
|
delayRetry(): Promise<void>;
|
|
695
|
-
divide(): /*elided*/ any[]
|
|
707
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
708
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
696
709
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
697
710
|
differentiate(task: Task): /*elided*/ any;
|
|
698
711
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -820,12 +833,15 @@ declare class CadenzaService {
|
|
|
820
833
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
821
834
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
822
835
|
onProgress(progress: number): void;
|
|
823
|
-
postProcess():
|
|
836
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
837
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
838
|
+
finalize(): void;
|
|
824
839
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
825
840
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
826
841
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
827
842
|
delayRetry(): Promise<void>;
|
|
828
|
-
divide(): /*elided*/ any[]
|
|
843
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
844
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
829
845
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
830
846
|
differentiate(task: Task): /*elided*/ any;
|
|
831
847
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -965,12 +981,15 @@ declare class CadenzaService {
|
|
|
965
981
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
966
982
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
967
983
|
onProgress(progress: number): void;
|
|
968
|
-
postProcess():
|
|
984
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
985
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
986
|
+
finalize(): void;
|
|
969
987
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
970
988
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
971
989
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
972
990
|
delayRetry(): Promise<void>;
|
|
973
|
-
divide(): /*elided*/ any[]
|
|
991
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
992
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
974
993
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
975
994
|
differentiate(task: Task): /*elided*/ any;
|
|
976
995
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -1148,12 +1167,15 @@ declare class CadenzaService {
|
|
|
1148
1167
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1149
1168
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1150
1169
|
onProgress(progress: number): void;
|
|
1151
|
-
postProcess():
|
|
1170
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1171
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
1172
|
+
finalize(): void;
|
|
1152
1173
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
1153
1174
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1154
1175
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1155
1176
|
delayRetry(): Promise<void>;
|
|
1156
|
-
divide(): /*elided*/ any[]
|
|
1177
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1178
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
1157
1179
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
1158
1180
|
differentiate(task: Task): /*elided*/ any;
|
|
1159
1181
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -1285,12 +1307,15 @@ declare class CadenzaService {
|
|
|
1285
1307
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1286
1308
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1287
1309
|
onProgress(progress: number): void;
|
|
1288
|
-
postProcess():
|
|
1310
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1311
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
1312
|
+
finalize(): void;
|
|
1289
1313
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
1290
1314
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1291
1315
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1292
1316
|
delayRetry(): Promise<void>;
|
|
1293
|
-
divide(): /*elided*/ any[]
|
|
1317
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1318
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
1294
1319
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
1295
1320
|
differentiate(task: Task): /*elided*/ any;
|
|
1296
1321
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -1415,12 +1440,15 @@ declare class CadenzaService {
|
|
|
1415
1440
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1416
1441
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1417
1442
|
onProgress(progress: number): void;
|
|
1418
|
-
postProcess():
|
|
1443
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1444
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
1445
|
+
finalize(): void;
|
|
1419
1446
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
1420
1447
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1421
1448
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1422
1449
|
delayRetry(): Promise<void>;
|
|
1423
|
-
divide(): /*elided*/ any[]
|
|
1450
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1451
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
1424
1452
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
1425
1453
|
differentiate(task: Task): /*elided*/ any;
|
|
1426
1454
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -1544,12 +1572,15 @@ declare class CadenzaService {
|
|
|
1544
1572
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1545
1573
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1546
1574
|
onProgress(progress: number): void;
|
|
1547
|
-
postProcess():
|
|
1575
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1576
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
1577
|
+
finalize(): void;
|
|
1548
1578
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
1549
1579
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1550
1580
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1551
1581
|
delayRetry(): Promise<void>;
|
|
1552
|
-
divide(): /*elided*/ any[]
|
|
1582
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1583
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
1553
1584
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
1554
1585
|
differentiate(task: Task): /*elided*/ any;
|
|
1555
1586
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -1677,12 +1708,15 @@ declare class CadenzaService {
|
|
|
1677
1708
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1678
1709
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1679
1710
|
onProgress(progress: number): void;
|
|
1680
|
-
postProcess():
|
|
1711
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1712
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
1713
|
+
finalize(): void;
|
|
1681
1714
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
1682
1715
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1683
1716
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1684
1717
|
delayRetry(): Promise<void>;
|
|
1685
|
-
divide(): /*elided*/ any[]
|
|
1718
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1719
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
1686
1720
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
1687
1721
|
differentiate(task: Task): /*elided*/ any;
|
|
1688
1722
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -1822,12 +1856,15 @@ declare class CadenzaService {
|
|
|
1822
1856
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1823
1857
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
1824
1858
|
onProgress(progress: number): void;
|
|
1825
|
-
postProcess():
|
|
1859
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1860
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
1861
|
+
finalize(): void;
|
|
1826
1862
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
1827
1863
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1828
1864
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
1829
1865
|
delayRetry(): Promise<void>;
|
|
1830
|
-
divide(): /*elided*/ any[]
|
|
1866
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
1867
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
1831
1868
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
1832
1869
|
differentiate(task: Task): /*elided*/ any;
|
|
1833
1870
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -2006,12 +2043,15 @@ declare class CadenzaService {
|
|
|
2006
2043
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2007
2044
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2008
2045
|
onProgress(progress: number): void;
|
|
2009
|
-
postProcess():
|
|
2046
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2047
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
2048
|
+
finalize(): void;
|
|
2010
2049
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
2011
2050
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2012
2051
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2013
2052
|
delayRetry(): Promise<void>;
|
|
2014
|
-
divide(): /*elided*/ any[]
|
|
2053
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2054
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
2015
2055
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
2016
2056
|
differentiate(task: Task): /*elided*/ any;
|
|
2017
2057
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -2143,12 +2183,15 @@ declare class CadenzaService {
|
|
|
2143
2183
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2144
2184
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2145
2185
|
onProgress(progress: number): void;
|
|
2146
|
-
postProcess():
|
|
2186
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2187
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
2188
|
+
finalize(): void;
|
|
2147
2189
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
2148
2190
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2149
2191
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2150
2192
|
delayRetry(): Promise<void>;
|
|
2151
|
-
divide(): /*elided*/ any[]
|
|
2193
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2194
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
2152
2195
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
2153
2196
|
differentiate(task: Task): /*elided*/ any;
|
|
2154
2197
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -2273,12 +2316,15 @@ declare class CadenzaService {
|
|
|
2273
2316
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2274
2317
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2275
2318
|
onProgress(progress: number): void;
|
|
2276
|
-
postProcess():
|
|
2319
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2320
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
2321
|
+
finalize(): void;
|
|
2277
2322
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
2278
2323
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2279
2324
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2280
2325
|
delayRetry(): Promise<void>;
|
|
2281
|
-
divide(): /*elided*/ any[]
|
|
2326
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2327
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
2282
2328
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
2283
2329
|
differentiate(task: Task): /*elided*/ any;
|
|
2284
2330
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -2402,12 +2448,15 @@ declare class CadenzaService {
|
|
|
2402
2448
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2403
2449
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2404
2450
|
onProgress(progress: number): void;
|
|
2405
|
-
postProcess():
|
|
2451
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2452
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
2453
|
+
finalize(): void;
|
|
2406
2454
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
2407
2455
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2408
2456
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2409
2457
|
delayRetry(): Promise<void>;
|
|
2410
|
-
divide(): /*elided*/ any[]
|
|
2458
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2459
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
2411
2460
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
2412
2461
|
differentiate(task: Task): /*elided*/ any;
|
|
2413
2462
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -2535,12 +2584,15 @@ declare class CadenzaService {
|
|
|
2535
2584
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2536
2585
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2537
2586
|
onProgress(progress: number): void;
|
|
2538
|
-
postProcess():
|
|
2587
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2588
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
2589
|
+
finalize(): void;
|
|
2539
2590
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
2540
2591
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2541
2592
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2542
2593
|
delayRetry(): Promise<void>;
|
|
2543
|
-
divide(): /*elided*/ any[]
|
|
2594
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2595
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
2544
2596
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
2545
2597
|
differentiate(task: Task): /*elided*/ any;
|
|
2546
2598
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -2680,12 +2732,15 @@ declare class CadenzaService {
|
|
|
2680
2732
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2681
2733
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
2682
2734
|
onProgress(progress: number): void;
|
|
2683
|
-
postProcess():
|
|
2735
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2736
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
2737
|
+
finalize(): void;
|
|
2684
2738
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
2685
2739
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2686
2740
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
2687
2741
|
delayRetry(): Promise<void>;
|
|
2688
|
-
divide(): /*elided*/ any[]
|
|
2742
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
2743
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
2689
2744
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
2690
2745
|
differentiate(task: Task): /*elided*/ any;
|
|
2691
2746
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -3031,12 +3086,15 @@ declare class CadenzaService {
|
|
|
3031
3086
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3032
3087
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3033
3088
|
onProgress(progress: number): void;
|
|
3034
|
-
postProcess():
|
|
3089
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3090
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
3091
|
+
finalize(): void;
|
|
3035
3092
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
3036
3093
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3037
3094
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3038
3095
|
delayRetry(): Promise<void>;
|
|
3039
|
-
divide(): /*elided*/ any[]
|
|
3096
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3097
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
3040
3098
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
3041
3099
|
differentiate(task: Task): /*elided*/ any;
|
|
3042
3100
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -3412,12 +3470,15 @@ declare class CadenzaService {
|
|
|
3412
3470
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3413
3471
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3414
3472
|
onProgress(progress: number): void;
|
|
3415
|
-
postProcess():
|
|
3473
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3474
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
3475
|
+
finalize(): void;
|
|
3416
3476
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
3417
3477
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3418
3478
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3419
3479
|
delayRetry(): Promise<void>;
|
|
3420
|
-
divide(): /*elided*/ any[]
|
|
3480
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3481
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
3421
3482
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
3422
3483
|
differentiate(task: Task): /*elided*/ any;
|
|
3423
3484
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -3626,12 +3687,15 @@ declare class CadenzaService {
|
|
|
3626
3687
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3627
3688
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3628
3689
|
onProgress(progress: number): void;
|
|
3629
|
-
postProcess():
|
|
3690
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3691
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
3692
|
+
finalize(): void;
|
|
3630
3693
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
3631
3694
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3632
3695
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3633
3696
|
delayRetry(): Promise<void>;
|
|
3634
|
-
divide(): /*elided*/ any[]
|
|
3697
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3698
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
3635
3699
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
3636
3700
|
differentiate(task: Task): /*elided*/ any;
|
|
3637
3701
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -3763,12 +3827,15 @@ declare class CadenzaService {
|
|
|
3763
3827
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3764
3828
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3765
3829
|
onProgress(progress: number): void;
|
|
3766
|
-
postProcess():
|
|
3830
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3831
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
3832
|
+
finalize(): void;
|
|
3767
3833
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
3768
3834
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3769
3835
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3770
3836
|
delayRetry(): Promise<void>;
|
|
3771
|
-
divide(): /*elided*/ any[]
|
|
3837
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3838
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
3772
3839
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
3773
3840
|
differentiate(task: Task): /*elided*/ any;
|
|
3774
3841
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -3893,12 +3960,15 @@ declare class CadenzaService {
|
|
|
3893
3960
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3894
3961
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
3895
3962
|
onProgress(progress: number): void;
|
|
3896
|
-
postProcess():
|
|
3963
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3964
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
3965
|
+
finalize(): void;
|
|
3897
3966
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
3898
3967
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3899
3968
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
3900
3969
|
delayRetry(): Promise<void>;
|
|
3901
|
-
divide(): /*elided*/ any[]
|
|
3970
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
3971
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
3902
3972
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
3903
3973
|
differentiate(task: Task): /*elided*/ any;
|
|
3904
3974
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -4022,12 +4092,15 @@ declare class CadenzaService {
|
|
|
4022
4092
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4023
4093
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4024
4094
|
onProgress(progress: number): void;
|
|
4025
|
-
postProcess():
|
|
4095
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4096
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
4097
|
+
finalize(): void;
|
|
4026
4098
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
4027
4099
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4028
4100
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4029
4101
|
delayRetry(): Promise<void>;
|
|
4030
|
-
divide(): /*elided*/ any[]
|
|
4102
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4103
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
4031
4104
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
4032
4105
|
differentiate(task: Task): /*elided*/ any;
|
|
4033
4106
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -4155,12 +4228,15 @@ declare class CadenzaService {
|
|
|
4155
4228
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4156
4229
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4157
4230
|
onProgress(progress: number): void;
|
|
4158
|
-
postProcess():
|
|
4231
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4232
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
4233
|
+
finalize(): void;
|
|
4159
4234
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
4160
4235
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4161
4236
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4162
4237
|
delayRetry(): Promise<void>;
|
|
4163
|
-
divide(): /*elided*/ any[]
|
|
4238
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4239
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
4164
4240
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
4165
4241
|
differentiate(task: Task): /*elided*/ any;
|
|
4166
4242
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -4300,12 +4376,15 @@ declare class CadenzaService {
|
|
|
4300
4376
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4301
4377
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4302
4378
|
onProgress(progress: number): void;
|
|
4303
|
-
postProcess():
|
|
4379
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4380
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
4381
|
+
finalize(): void;
|
|
4304
4382
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
4305
4383
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4306
4384
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4307
4385
|
delayRetry(): Promise<void>;
|
|
4308
|
-
divide(): /*elided*/ any[]
|
|
4386
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4387
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
4309
4388
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
4310
4389
|
differentiate(task: Task): /*elided*/ any;
|
|
4311
4390
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -4482,12 +4561,15 @@ declare class CadenzaService {
|
|
|
4482
4561
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4483
4562
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4484
4563
|
onProgress(progress: number): void;
|
|
4485
|
-
postProcess():
|
|
4564
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4565
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
4566
|
+
finalize(): void;
|
|
4486
4567
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
4487
4568
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4488
4569
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4489
4570
|
delayRetry(): Promise<void>;
|
|
4490
|
-
divide(): /*elided*/ any[]
|
|
4571
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4572
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
4491
4573
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
4492
4574
|
differentiate(task: Task): /*elided*/ any;
|
|
4493
4575
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -4619,12 +4701,15 @@ declare class CadenzaService {
|
|
|
4619
4701
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4620
4702
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4621
4703
|
onProgress(progress: number): void;
|
|
4622
|
-
postProcess():
|
|
4704
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4705
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
4706
|
+
finalize(): void;
|
|
4623
4707
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
4624
4708
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4625
4709
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4626
4710
|
delayRetry(): Promise<void>;
|
|
4627
|
-
divide(): /*elided*/ any[]
|
|
4711
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4712
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
4628
4713
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
4629
4714
|
differentiate(task: Task): /*elided*/ any;
|
|
4630
4715
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -4749,12 +4834,15 @@ declare class CadenzaService {
|
|
|
4749
4834
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4750
4835
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4751
4836
|
onProgress(progress: number): void;
|
|
4752
|
-
postProcess():
|
|
4837
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4838
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
4839
|
+
finalize(): void;
|
|
4753
4840
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
4754
4841
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4755
4842
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4756
4843
|
delayRetry(): Promise<void>;
|
|
4757
|
-
divide(): /*elided*/ any[]
|
|
4844
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4845
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
4758
4846
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
4759
4847
|
differentiate(task: Task): /*elided*/ any;
|
|
4760
4848
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -4878,12 +4966,15 @@ declare class CadenzaService {
|
|
|
4878
4966
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4879
4967
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
4880
4968
|
onProgress(progress: number): void;
|
|
4881
|
-
postProcess():
|
|
4969
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4970
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
4971
|
+
finalize(): void;
|
|
4882
4972
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
4883
4973
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4884
4974
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
4885
4975
|
delayRetry(): Promise<void>;
|
|
4886
|
-
divide(): /*elided*/ any[]
|
|
4976
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
4977
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
4887
4978
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
4888
4979
|
differentiate(task: Task): /*elided*/ any;
|
|
4889
4980
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -5011,12 +5102,15 @@ declare class CadenzaService {
|
|
|
5011
5102
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5012
5103
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5013
5104
|
onProgress(progress: number): void;
|
|
5014
|
-
postProcess():
|
|
5105
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5106
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
5107
|
+
finalize(): void;
|
|
5015
5108
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
5016
5109
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5017
5110
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5018
5111
|
delayRetry(): Promise<void>;
|
|
5019
|
-
divide(): /*elided*/ any[]
|
|
5112
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5113
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
5020
5114
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
5021
5115
|
differentiate(task: Task): /*elided*/ any;
|
|
5022
5116
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -5156,12 +5250,15 @@ declare class CadenzaService {
|
|
|
5156
5250
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5157
5251
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5158
5252
|
onProgress(progress: number): void;
|
|
5159
|
-
postProcess():
|
|
5253
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5254
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
5255
|
+
finalize(): void;
|
|
5160
5256
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
5161
5257
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5162
5258
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5163
5259
|
delayRetry(): Promise<void>;
|
|
5164
|
-
divide(): /*elided*/ any[]
|
|
5260
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5261
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
5165
5262
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
5166
5263
|
differentiate(task: Task): /*elided*/ any;
|
|
5167
5264
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -5343,12 +5440,15 @@ declare class CadenzaService {
|
|
|
5343
5440
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5344
5441
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5345
5442
|
onProgress(progress: number): void;
|
|
5346
|
-
postProcess():
|
|
5443
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5444
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
5445
|
+
finalize(): void;
|
|
5347
5446
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
5348
5447
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5349
5448
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5350
5449
|
delayRetry(): Promise<void>;
|
|
5351
|
-
divide(): /*elided*/ any[]
|
|
5450
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5451
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
5352
5452
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
5353
5453
|
differentiate(task: Task): /*elided*/ any;
|
|
5354
5454
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -5480,12 +5580,15 @@ declare class CadenzaService {
|
|
|
5480
5580
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5481
5581
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5482
5582
|
onProgress(progress: number): void;
|
|
5483
|
-
postProcess():
|
|
5583
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5584
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
5585
|
+
finalize(): void;
|
|
5484
5586
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
5485
5587
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5486
5588
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5487
5589
|
delayRetry(): Promise<void>;
|
|
5488
|
-
divide(): /*elided*/ any[]
|
|
5590
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5591
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
5489
5592
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
5490
5593
|
differentiate(task: Task): /*elided*/ any;
|
|
5491
5594
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -5610,12 +5713,15 @@ declare class CadenzaService {
|
|
|
5610
5713
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5611
5714
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5612
5715
|
onProgress(progress: number): void;
|
|
5613
|
-
postProcess():
|
|
5716
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5717
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
5718
|
+
finalize(): void;
|
|
5614
5719
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
5615
5720
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5616
5721
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5617
5722
|
delayRetry(): Promise<void>;
|
|
5618
|
-
divide(): /*elided*/ any[]
|
|
5723
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5724
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
5619
5725
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
5620
5726
|
differentiate(task: Task): /*elided*/ any;
|
|
5621
5727
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -5739,12 +5845,15 @@ declare class CadenzaService {
|
|
|
5739
5845
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5740
5846
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5741
5847
|
onProgress(progress: number): void;
|
|
5742
|
-
postProcess():
|
|
5848
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5849
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
5850
|
+
finalize(): void;
|
|
5743
5851
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
5744
5852
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5745
5853
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5746
5854
|
delayRetry(): Promise<void>;
|
|
5747
|
-
divide(): /*elided*/ any[]
|
|
5855
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5856
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
5748
5857
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
5749
5858
|
differentiate(task: Task): /*elided*/ any;
|
|
5750
5859
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -5872,12 +5981,15 @@ declare class CadenzaService {
|
|
|
5872
5981
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5873
5982
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
5874
5983
|
onProgress(progress: number): void;
|
|
5875
|
-
postProcess():
|
|
5984
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5985
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
5986
|
+
finalize(): void;
|
|
5876
5987
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
5877
5988
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5878
5989
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
5879
5990
|
delayRetry(): Promise<void>;
|
|
5880
|
-
divide(): /*elided*/ any[]
|
|
5991
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
5992
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
5881
5993
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
5882
5994
|
differentiate(task: Task): /*elided*/ any;
|
|
5883
5995
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -6017,12 +6129,15 @@ declare class CadenzaService {
|
|
|
6017
6129
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6018
6130
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6019
6131
|
onProgress(progress: number): void;
|
|
6020
|
-
postProcess():
|
|
6132
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6133
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
6134
|
+
finalize(): void;
|
|
6021
6135
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
6022
6136
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6023
6137
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6024
6138
|
delayRetry(): Promise<void>;
|
|
6025
|
-
divide(): /*elided*/ any[]
|
|
6139
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6140
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
6026
6141
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
6027
6142
|
differentiate(task: Task): /*elided*/ any;
|
|
6028
6143
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -6200,12 +6315,15 @@ declare class CadenzaService {
|
|
|
6200
6315
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6201
6316
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6202
6317
|
onProgress(progress: number): void;
|
|
6203
|
-
postProcess():
|
|
6318
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6319
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
6320
|
+
finalize(): void;
|
|
6204
6321
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
6205
6322
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6206
6323
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6207
6324
|
delayRetry(): Promise<void>;
|
|
6208
|
-
divide(): /*elided*/ any[]
|
|
6325
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6326
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
6209
6327
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
6210
6328
|
differentiate(task: Task): /*elided*/ any;
|
|
6211
6329
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -6337,12 +6455,15 @@ declare class CadenzaService {
|
|
|
6337
6455
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6338
6456
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6339
6457
|
onProgress(progress: number): void;
|
|
6340
|
-
postProcess():
|
|
6458
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6459
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
6460
|
+
finalize(): void;
|
|
6341
6461
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
6342
6462
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6343
6463
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6344
6464
|
delayRetry(): Promise<void>;
|
|
6345
|
-
divide(): /*elided*/ any[]
|
|
6465
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6466
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
6346
6467
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
6347
6468
|
differentiate(task: Task): /*elided*/ any;
|
|
6348
6469
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -6467,12 +6588,15 @@ declare class CadenzaService {
|
|
|
6467
6588
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6468
6589
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6469
6590
|
onProgress(progress: number): void;
|
|
6470
|
-
postProcess():
|
|
6591
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6592
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
6593
|
+
finalize(): void;
|
|
6471
6594
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
6472
6595
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6473
6596
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6474
6597
|
delayRetry(): Promise<void>;
|
|
6475
|
-
divide(): /*elided*/ any[]
|
|
6598
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6599
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
6476
6600
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
6477
6601
|
differentiate(task: Task): /*elided*/ any;
|
|
6478
6602
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -6596,12 +6720,15 @@ declare class CadenzaService {
|
|
|
6596
6720
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6597
6721
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6598
6722
|
onProgress(progress: number): void;
|
|
6599
|
-
postProcess():
|
|
6723
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6724
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
6725
|
+
finalize(): void;
|
|
6600
6726
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
6601
6727
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6602
6728
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6603
6729
|
delayRetry(): Promise<void>;
|
|
6604
|
-
divide(): /*elided*/ any[]
|
|
6730
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6731
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
6605
6732
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
6606
6733
|
differentiate(task: Task): /*elided*/ any;
|
|
6607
6734
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -6729,12 +6856,15 @@ declare class CadenzaService {
|
|
|
6729
6856
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6730
6857
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6731
6858
|
onProgress(progress: number): void;
|
|
6732
|
-
postProcess():
|
|
6859
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6860
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
6861
|
+
finalize(): void;
|
|
6733
6862
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
6734
6863
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6735
6864
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6736
6865
|
delayRetry(): Promise<void>;
|
|
6737
|
-
divide(): /*elided*/ any[]
|
|
6866
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
6867
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
6738
6868
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
6739
6869
|
differentiate(task: Task): /*elided*/ any;
|
|
6740
6870
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -6874,12 +7004,15 @@ declare class CadenzaService {
|
|
|
6874
7004
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6875
7005
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
6876
7006
|
onProgress(progress: number): void;
|
|
6877
|
-
postProcess():
|
|
7007
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7008
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
7009
|
+
finalize(): void;
|
|
6878
7010
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
6879
7011
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6880
7012
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
6881
7013
|
delayRetry(): Promise<void>;
|
|
6882
|
-
divide(): /*elided*/ any[]
|
|
7014
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7015
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
6883
7016
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
6884
7017
|
differentiate(task: Task): /*elided*/ any;
|
|
6885
7018
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -7058,12 +7191,15 @@ declare class CadenzaService {
|
|
|
7058
7191
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7059
7192
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7060
7193
|
onProgress(progress: number): void;
|
|
7061
|
-
postProcess():
|
|
7194
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7195
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
7196
|
+
finalize(): void;
|
|
7062
7197
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
7063
7198
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7064
7199
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7065
7200
|
delayRetry(): Promise<void>;
|
|
7066
|
-
divide(): /*elided*/ any[]
|
|
7201
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7202
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
7067
7203
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
7068
7204
|
differentiate(task: Task): /*elided*/ any;
|
|
7069
7205
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -7195,12 +7331,15 @@ declare class CadenzaService {
|
|
|
7195
7331
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7196
7332
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7197
7333
|
onProgress(progress: number): void;
|
|
7198
|
-
postProcess():
|
|
7334
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7335
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
7336
|
+
finalize(): void;
|
|
7199
7337
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
7200
7338
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7201
7339
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7202
7340
|
delayRetry(): Promise<void>;
|
|
7203
|
-
divide(): /*elided*/ any[]
|
|
7341
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7342
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
7204
7343
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
7205
7344
|
differentiate(task: Task): /*elided*/ any;
|
|
7206
7345
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -7325,12 +7464,15 @@ declare class CadenzaService {
|
|
|
7325
7464
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7326
7465
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7327
7466
|
onProgress(progress: number): void;
|
|
7328
|
-
postProcess():
|
|
7467
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7468
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
7469
|
+
finalize(): void;
|
|
7329
7470
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
7330
7471
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7331
7472
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7332
7473
|
delayRetry(): Promise<void>;
|
|
7333
|
-
divide(): /*elided*/ any[]
|
|
7474
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7475
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
7334
7476
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
7335
7477
|
differentiate(task: Task): /*elided*/ any;
|
|
7336
7478
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -7454,12 +7596,15 @@ declare class CadenzaService {
|
|
|
7454
7596
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7455
7597
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7456
7598
|
onProgress(progress: number): void;
|
|
7457
|
-
postProcess():
|
|
7599
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7600
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
7601
|
+
finalize(): void;
|
|
7458
7602
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
7459
7603
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7460
7604
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7461
7605
|
delayRetry(): Promise<void>;
|
|
7462
|
-
divide(): /*elided*/ any[]
|
|
7606
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7607
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
7463
7608
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
7464
7609
|
differentiate(task: Task): /*elided*/ any;
|
|
7465
7610
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -7587,12 +7732,15 @@ declare class CadenzaService {
|
|
|
7587
7732
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7588
7733
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7589
7734
|
onProgress(progress: number): void;
|
|
7590
|
-
postProcess():
|
|
7735
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7736
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
7737
|
+
finalize(): void;
|
|
7591
7738
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
7592
7739
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7593
7740
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7594
7741
|
delayRetry(): Promise<void>;
|
|
7595
|
-
divide(): /*elided*/ any[]
|
|
7742
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7743
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
7596
7744
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
7597
7745
|
differentiate(task: Task): /*elided*/ any;
|
|
7598
7746
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -7732,12 +7880,15 @@ declare class CadenzaService {
|
|
|
7732
7880
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7733
7881
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
7734
7882
|
onProgress(progress: number): void;
|
|
7735
|
-
postProcess():
|
|
7883
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7884
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
7885
|
+
finalize(): void;
|
|
7736
7886
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
7737
7887
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7738
7888
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
7739
7889
|
delayRetry(): Promise<void>;
|
|
7740
|
-
divide(): /*elided*/ any[]
|
|
7890
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
7891
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
7741
7892
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
7742
7893
|
differentiate(task: Task): /*elided*/ any;
|
|
7743
7894
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -8083,12 +8234,15 @@ declare class CadenzaService {
|
|
|
8083
8234
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8084
8235
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8085
8236
|
onProgress(progress: number): void;
|
|
8086
|
-
postProcess():
|
|
8237
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
8238
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
8239
|
+
finalize(): void;
|
|
8087
8240
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
8088
8241
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8089
8242
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8090
8243
|
delayRetry(): Promise<void>;
|
|
8091
|
-
divide(): /*elided*/ any[]
|
|
8244
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
8245
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
8092
8246
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
8093
8247
|
differentiate(task: Task): /*elided*/ any;
|
|
8094
8248
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -8464,12 +8618,15 @@ declare class CadenzaService {
|
|
|
8464
8618
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8465
8619
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8466
8620
|
onProgress(progress: number): void;
|
|
8467
|
-
postProcess():
|
|
8621
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
8622
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
8623
|
+
finalize(): void;
|
|
8468
8624
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
8469
8625
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8470
8626
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8471
8627
|
delayRetry(): Promise<void>;
|
|
8472
|
-
divide(): /*elided*/ any[]
|
|
8628
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
8629
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
8473
8630
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
8474
8631
|
differentiate(task: Task): /*elided*/ any;
|
|
8475
8632
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -8678,12 +8835,15 @@ declare class CadenzaService {
|
|
|
8678
8835
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8679
8836
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8680
8837
|
onProgress(progress: number): void;
|
|
8681
|
-
postProcess():
|
|
8838
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
8839
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
8840
|
+
finalize(): void;
|
|
8682
8841
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
8683
8842
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8684
8843
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8685
8844
|
delayRetry(): Promise<void>;
|
|
8686
|
-
divide(): /*elided*/ any[]
|
|
8845
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
8846
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
8687
8847
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
8688
8848
|
differentiate(task: Task): /*elided*/ any;
|
|
8689
8849
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -8815,12 +8975,15 @@ declare class CadenzaService {
|
|
|
8815
8975
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8816
8976
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8817
8977
|
onProgress(progress: number): void;
|
|
8818
|
-
postProcess():
|
|
8978
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
8979
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
8980
|
+
finalize(): void;
|
|
8819
8981
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
8820
8982
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8821
8983
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8822
8984
|
delayRetry(): Promise<void>;
|
|
8823
|
-
divide(): /*elided*/ any[]
|
|
8985
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
8986
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
8824
8987
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
8825
8988
|
differentiate(task: Task): /*elided*/ any;
|
|
8826
8989
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -8945,12 +9108,15 @@ declare class CadenzaService {
|
|
|
8945
9108
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8946
9109
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
8947
9110
|
onProgress(progress: number): void;
|
|
8948
|
-
postProcess():
|
|
9111
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9112
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
9113
|
+
finalize(): void;
|
|
8949
9114
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
8950
9115
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8951
9116
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
8952
9117
|
delayRetry(): Promise<void>;
|
|
8953
|
-
divide(): /*elided*/ any[]
|
|
9118
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9119
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
8954
9120
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
8955
9121
|
differentiate(task: Task): /*elided*/ any;
|
|
8956
9122
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -9074,12 +9240,15 @@ declare class CadenzaService {
|
|
|
9074
9240
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9075
9241
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9076
9242
|
onProgress(progress: number): void;
|
|
9077
|
-
postProcess():
|
|
9243
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9244
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
9245
|
+
finalize(): void;
|
|
9078
9246
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
9079
9247
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9080
9248
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9081
9249
|
delayRetry(): Promise<void>;
|
|
9082
|
-
divide(): /*elided*/ any[]
|
|
9250
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9251
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
9083
9252
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
9084
9253
|
differentiate(task: Task): /*elided*/ any;
|
|
9085
9254
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -9207,12 +9376,15 @@ declare class CadenzaService {
|
|
|
9207
9376
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9208
9377
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9209
9378
|
onProgress(progress: number): void;
|
|
9210
|
-
postProcess():
|
|
9379
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9380
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
9381
|
+
finalize(): void;
|
|
9211
9382
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
9212
9383
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9213
9384
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9214
9385
|
delayRetry(): Promise<void>;
|
|
9215
|
-
divide(): /*elided*/ any[]
|
|
9386
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9387
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
9216
9388
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
9217
9389
|
differentiate(task: Task): /*elided*/ any;
|
|
9218
9390
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -9352,12 +9524,15 @@ declare class CadenzaService {
|
|
|
9352
9524
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9353
9525
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9354
9526
|
onProgress(progress: number): void;
|
|
9355
|
-
postProcess():
|
|
9527
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9528
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
9529
|
+
finalize(): void;
|
|
9356
9530
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
9357
9531
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9358
9532
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9359
9533
|
delayRetry(): Promise<void>;
|
|
9360
|
-
divide(): /*elided*/ any[]
|
|
9534
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9535
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
9361
9536
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
9362
9537
|
differentiate(task: Task): /*elided*/ any;
|
|
9363
9538
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -9534,12 +9709,15 @@ declare class CadenzaService {
|
|
|
9534
9709
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9535
9710
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9536
9711
|
onProgress(progress: number): void;
|
|
9537
|
-
postProcess():
|
|
9712
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9713
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
9714
|
+
finalize(): void;
|
|
9538
9715
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
9539
9716
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9540
9717
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9541
9718
|
delayRetry(): Promise<void>;
|
|
9542
|
-
divide(): /*elided*/ any[]
|
|
9719
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9720
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
9543
9721
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
9544
9722
|
differentiate(task: Task): /*elided*/ any;
|
|
9545
9723
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -9671,12 +9849,15 @@ declare class CadenzaService {
|
|
|
9671
9849
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9672
9850
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9673
9851
|
onProgress(progress: number): void;
|
|
9674
|
-
postProcess():
|
|
9852
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9853
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
9854
|
+
finalize(): void;
|
|
9675
9855
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
9676
9856
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9677
9857
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9678
9858
|
delayRetry(): Promise<void>;
|
|
9679
|
-
divide(): /*elided*/ any[]
|
|
9859
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9860
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
9680
9861
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
9681
9862
|
differentiate(task: Task): /*elided*/ any;
|
|
9682
9863
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -9801,12 +9982,15 @@ declare class CadenzaService {
|
|
|
9801
9982
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9802
9983
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9803
9984
|
onProgress(progress: number): void;
|
|
9804
|
-
postProcess():
|
|
9985
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9986
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
9987
|
+
finalize(): void;
|
|
9805
9988
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
9806
9989
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9807
9990
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9808
9991
|
delayRetry(): Promise<void>;
|
|
9809
|
-
divide(): /*elided*/ any[]
|
|
9992
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
9993
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
9810
9994
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
9811
9995
|
differentiate(task: Task): /*elided*/ any;
|
|
9812
9996
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -9930,12 +10114,15 @@ declare class CadenzaService {
|
|
|
9930
10114
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9931
10115
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
9932
10116
|
onProgress(progress: number): void;
|
|
9933
|
-
postProcess():
|
|
10117
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10118
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
10119
|
+
finalize(): void;
|
|
9934
10120
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
9935
10121
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9936
10122
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
9937
10123
|
delayRetry(): Promise<void>;
|
|
9938
|
-
divide(): /*elided*/ any[]
|
|
10124
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10125
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
9939
10126
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
9940
10127
|
differentiate(task: Task): /*elided*/ any;
|
|
9941
10128
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -10063,12 +10250,15 @@ declare class CadenzaService {
|
|
|
10063
10250
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10064
10251
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10065
10252
|
onProgress(progress: number): void;
|
|
10066
|
-
postProcess():
|
|
10253
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10254
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
10255
|
+
finalize(): void;
|
|
10067
10256
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
10068
10257
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10069
10258
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10070
10259
|
delayRetry(): Promise<void>;
|
|
10071
|
-
divide(): /*elided*/ any[]
|
|
10260
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10261
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
10072
10262
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
10073
10263
|
differentiate(task: Task): /*elided*/ any;
|
|
10074
10264
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -10208,12 +10398,15 @@ declare class CadenzaService {
|
|
|
10208
10398
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10209
10399
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10210
10400
|
onProgress(progress: number): void;
|
|
10211
|
-
postProcess():
|
|
10401
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10402
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
10403
|
+
finalize(): void;
|
|
10212
10404
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
10213
10405
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10214
10406
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10215
10407
|
delayRetry(): Promise<void>;
|
|
10216
|
-
divide(): /*elided*/ any[]
|
|
10408
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10409
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
10217
10410
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
10218
10411
|
differentiate(task: Task): /*elided*/ any;
|
|
10219
10412
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -10560,12 +10753,15 @@ declare class CadenzaService {
|
|
|
10560
10753
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10561
10754
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10562
10755
|
onProgress(progress: number): void;
|
|
10563
|
-
postProcess():
|
|
10756
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10757
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
10758
|
+
finalize(): void;
|
|
10564
10759
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
10565
10760
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10566
10761
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10567
10762
|
delayRetry(): Promise<void>;
|
|
10568
|
-
divide(): /*elided*/ any[]
|
|
10763
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10764
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
10569
10765
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
10570
10766
|
differentiate(task: Task): /*elided*/ any;
|
|
10571
10767
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -10779,12 +10975,15 @@ declare class CadenzaService {
|
|
|
10779
10975
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10780
10976
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10781
10977
|
onProgress(progress: number): void;
|
|
10782
|
-
postProcess():
|
|
10978
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10979
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
10980
|
+
finalize(): void;
|
|
10783
10981
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
10784
10982
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10785
10983
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10786
10984
|
delayRetry(): Promise<void>;
|
|
10787
|
-
divide(): /*elided*/ any[]
|
|
10985
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
10986
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
10788
10987
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
10789
10988
|
differentiate(task: Task): /*elided*/ any;
|
|
10790
10989
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -10916,12 +11115,15 @@ declare class CadenzaService {
|
|
|
10916
11115
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10917
11116
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
10918
11117
|
onProgress(progress: number): void;
|
|
10919
|
-
postProcess():
|
|
11118
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11119
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
11120
|
+
finalize(): void;
|
|
10920
11121
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
10921
11122
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10922
11123
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
10923
11124
|
delayRetry(): Promise<void>;
|
|
10924
|
-
divide(): /*elided*/ any[]
|
|
11125
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11126
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
10925
11127
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
10926
11128
|
differentiate(task: Task): /*elided*/ any;
|
|
10927
11129
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -11046,12 +11248,15 @@ declare class CadenzaService {
|
|
|
11046
11248
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11047
11249
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11048
11250
|
onProgress(progress: number): void;
|
|
11049
|
-
postProcess():
|
|
11251
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11252
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
11253
|
+
finalize(): void;
|
|
11050
11254
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
11051
11255
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11052
11256
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11053
11257
|
delayRetry(): Promise<void>;
|
|
11054
|
-
divide(): /*elided*/ any[]
|
|
11258
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11259
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
11055
11260
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
11056
11261
|
differentiate(task: Task): /*elided*/ any;
|
|
11057
11262
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -11175,12 +11380,15 @@ declare class CadenzaService {
|
|
|
11175
11380
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11176
11381
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11177
11382
|
onProgress(progress: number): void;
|
|
11178
|
-
postProcess():
|
|
11383
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11384
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
11385
|
+
finalize(): void;
|
|
11179
11386
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
11180
11387
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11181
11388
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11182
11389
|
delayRetry(): Promise<void>;
|
|
11183
|
-
divide(): /*elided*/ any[]
|
|
11390
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11391
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
11184
11392
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
11185
11393
|
differentiate(task: Task): /*elided*/ any;
|
|
11186
11394
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -11308,12 +11516,15 @@ declare class CadenzaService {
|
|
|
11308
11516
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11309
11517
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11310
11518
|
onProgress(progress: number): void;
|
|
11311
|
-
postProcess():
|
|
11519
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11520
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
11521
|
+
finalize(): void;
|
|
11312
11522
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
11313
11523
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11314
11524
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11315
11525
|
delayRetry(): Promise<void>;
|
|
11316
|
-
divide(): /*elided*/ any[]
|
|
11526
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11527
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
11317
11528
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
11318
11529
|
differentiate(task: Task): /*elided*/ any;
|
|
11319
11530
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -11453,12 +11664,15 @@ declare class CadenzaService {
|
|
|
11453
11664
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11454
11665
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11455
11666
|
onProgress(progress: number): void;
|
|
11456
|
-
postProcess():
|
|
11667
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11668
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
11669
|
+
finalize(): void;
|
|
11457
11670
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
11458
11671
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11459
11672
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11460
11673
|
delayRetry(): Promise<void>;
|
|
11461
|
-
divide(): /*elided*/ any[]
|
|
11674
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11675
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
11462
11676
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
11463
11677
|
differentiate(task: Task): /*elided*/ any;
|
|
11464
11678
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -11636,12 +11850,15 @@ declare class CadenzaService {
|
|
|
11636
11850
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11637
11851
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11638
11852
|
onProgress(progress: number): void;
|
|
11639
|
-
postProcess():
|
|
11853
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11854
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
11855
|
+
finalize(): void;
|
|
11640
11856
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
11641
11857
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11642
11858
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11643
11859
|
delayRetry(): Promise<void>;
|
|
11644
|
-
divide(): /*elided*/ any[]
|
|
11860
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11861
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
11645
11862
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
11646
11863
|
differentiate(task: Task): /*elided*/ any;
|
|
11647
11864
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -11773,12 +11990,15 @@ declare class CadenzaService {
|
|
|
11773
11990
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11774
11991
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11775
11992
|
onProgress(progress: number): void;
|
|
11776
|
-
postProcess():
|
|
11993
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
11994
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
11995
|
+
finalize(): void;
|
|
11777
11996
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
11778
11997
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11779
11998
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11780
11999
|
delayRetry(): Promise<void>;
|
|
11781
|
-
divide(): /*elided*/ any[]
|
|
12000
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12001
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
11782
12002
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
11783
12003
|
differentiate(task: Task): /*elided*/ any;
|
|
11784
12004
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -11903,12 +12123,15 @@ declare class CadenzaService {
|
|
|
11903
12123
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11904
12124
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
11905
12125
|
onProgress(progress: number): void;
|
|
11906
|
-
postProcess():
|
|
12126
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12127
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
12128
|
+
finalize(): void;
|
|
11907
12129
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
11908
12130
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11909
12131
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
11910
12132
|
delayRetry(): Promise<void>;
|
|
11911
|
-
divide(): /*elided*/ any[]
|
|
12133
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12134
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
11912
12135
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
11913
12136
|
differentiate(task: Task): /*elided*/ any;
|
|
11914
12137
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -12032,12 +12255,15 @@ declare class CadenzaService {
|
|
|
12032
12255
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12033
12256
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12034
12257
|
onProgress(progress: number): void;
|
|
12035
|
-
postProcess():
|
|
12258
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12259
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
12260
|
+
finalize(): void;
|
|
12036
12261
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
12037
12262
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12038
12263
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12039
12264
|
delayRetry(): Promise<void>;
|
|
12040
|
-
divide(): /*elided*/ any[]
|
|
12265
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12266
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
12041
12267
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
12042
12268
|
differentiate(task: Task): /*elided*/ any;
|
|
12043
12269
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -12165,12 +12391,15 @@ declare class CadenzaService {
|
|
|
12165
12391
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12166
12392
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12167
12393
|
onProgress(progress: number): void;
|
|
12168
|
-
postProcess():
|
|
12394
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12395
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
12396
|
+
finalize(): void;
|
|
12169
12397
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
12170
12398
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12171
12399
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12172
12400
|
delayRetry(): Promise<void>;
|
|
12173
|
-
divide(): /*elided*/ any[]
|
|
12401
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12402
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
12174
12403
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
12175
12404
|
differentiate(task: Task): /*elided*/ any;
|
|
12176
12405
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -12310,12 +12539,15 @@ declare class CadenzaService {
|
|
|
12310
12539
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12311
12540
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12312
12541
|
onProgress(progress: number): void;
|
|
12313
|
-
postProcess():
|
|
12542
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12543
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
12544
|
+
finalize(): void;
|
|
12314
12545
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
12315
12546
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12316
12547
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12317
12548
|
delayRetry(): Promise<void>;
|
|
12318
|
-
divide(): /*elided*/ any[]
|
|
12549
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12550
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
12319
12551
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
12320
12552
|
differentiate(task: Task): /*elided*/ any;
|
|
12321
12553
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -12494,12 +12726,15 @@ declare class CadenzaService {
|
|
|
12494
12726
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12495
12727
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12496
12728
|
onProgress(progress: number): void;
|
|
12497
|
-
postProcess():
|
|
12729
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12730
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
12731
|
+
finalize(): void;
|
|
12498
12732
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
12499
12733
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12500
12734
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12501
12735
|
delayRetry(): Promise<void>;
|
|
12502
|
-
divide(): /*elided*/ any[]
|
|
12736
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12737
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
12503
12738
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
12504
12739
|
differentiate(task: Task): /*elided*/ any;
|
|
12505
12740
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -12631,12 +12866,15 @@ declare class CadenzaService {
|
|
|
12631
12866
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12632
12867
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12633
12868
|
onProgress(progress: number): void;
|
|
12634
|
-
postProcess():
|
|
12869
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12870
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
12871
|
+
finalize(): void;
|
|
12635
12872
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
12636
12873
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12637
12874
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12638
12875
|
delayRetry(): Promise<void>;
|
|
12639
|
-
divide(): /*elided*/ any[]
|
|
12876
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
12877
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
12640
12878
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
12641
12879
|
differentiate(task: Task): /*elided*/ any;
|
|
12642
12880
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -12761,12 +12999,15 @@ declare class CadenzaService {
|
|
|
12761
12999
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12762
13000
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12763
13001
|
onProgress(progress: number): void;
|
|
12764
|
-
postProcess():
|
|
13002
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13003
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
13004
|
+
finalize(): void;
|
|
12765
13005
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
12766
13006
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12767
13007
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12768
13008
|
delayRetry(): Promise<void>;
|
|
12769
|
-
divide(): /*elided*/ any[]
|
|
13009
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13010
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
12770
13011
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
12771
13012
|
differentiate(task: Task): /*elided*/ any;
|
|
12772
13013
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -12890,12 +13131,15 @@ declare class CadenzaService {
|
|
|
12890
13131
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12891
13132
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
12892
13133
|
onProgress(progress: number): void;
|
|
12893
|
-
postProcess():
|
|
13134
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13135
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
13136
|
+
finalize(): void;
|
|
12894
13137
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
12895
13138
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12896
13139
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
12897
13140
|
delayRetry(): Promise<void>;
|
|
12898
|
-
divide(): /*elided*/ any[]
|
|
13141
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13142
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
12899
13143
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
12900
13144
|
differentiate(task: Task): /*elided*/ any;
|
|
12901
13145
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -13023,12 +13267,15 @@ declare class CadenzaService {
|
|
|
13023
13267
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
13024
13268
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
13025
13269
|
onProgress(progress: number): void;
|
|
13026
|
-
postProcess():
|
|
13270
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13271
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
13272
|
+
finalize(): void;
|
|
13027
13273
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
13028
13274
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
13029
13275
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
13030
13276
|
delayRetry(): Promise<void>;
|
|
13031
|
-
divide(): /*elided*/ any[]
|
|
13277
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13278
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
13032
13279
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
13033
13280
|
differentiate(task: Task): /*elided*/ any;
|
|
13034
13281
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -13168,12 +13415,15 @@ declare class CadenzaService {
|
|
|
13168
13415
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
13169
13416
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
13170
13417
|
onProgress(progress: number): void;
|
|
13171
|
-
postProcess():
|
|
13418
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13419
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
13420
|
+
finalize(): void;
|
|
13172
13421
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
13173
13422
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
13174
13423
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
13175
13424
|
delayRetry(): Promise<void>;
|
|
13176
|
-
divide(): /*elided*/ any[]
|
|
13425
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13426
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
13177
13427
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
13178
13428
|
differentiate(task: Task): /*elided*/ any;
|
|
13179
13429
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -13519,12 +13769,15 @@ declare class CadenzaService {
|
|
|
13519
13769
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
13520
13770
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
13521
13771
|
onProgress(progress: number): void;
|
|
13522
|
-
postProcess():
|
|
13772
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13773
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
13774
|
+
finalize(): void;
|
|
13523
13775
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
13524
13776
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
13525
13777
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
13526
13778
|
delayRetry(): Promise<void>;
|
|
13527
|
-
divide(): /*elided*/ any[]
|
|
13779
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
13780
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
13528
13781
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
13529
13782
|
differentiate(task: Task): /*elided*/ any;
|
|
13530
13783
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -13900,12 +14153,15 @@ declare class CadenzaService {
|
|
|
13900
14153
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
13901
14154
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
13902
14155
|
onProgress(progress: number): void;
|
|
13903
|
-
postProcess():
|
|
14156
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14157
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
14158
|
+
finalize(): void;
|
|
13904
14159
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
13905
14160
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
13906
14161
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
13907
14162
|
delayRetry(): Promise<void>;
|
|
13908
|
-
divide(): /*elided*/ any[]
|
|
14163
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14164
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
13909
14165
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
13910
14166
|
differentiate(task: Task): /*elided*/ any;
|
|
13911
14167
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -14114,12 +14370,15 @@ declare class CadenzaService {
|
|
|
14114
14370
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14115
14371
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14116
14372
|
onProgress(progress: number): void;
|
|
14117
|
-
postProcess():
|
|
14373
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14374
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
14375
|
+
finalize(): void;
|
|
14118
14376
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
14119
14377
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14120
14378
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14121
14379
|
delayRetry(): Promise<void>;
|
|
14122
|
-
divide(): /*elided*/ any[]
|
|
14380
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14381
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
14123
14382
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
14124
14383
|
differentiate(task: Task): /*elided*/ any;
|
|
14125
14384
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -14251,12 +14510,15 @@ declare class CadenzaService {
|
|
|
14251
14510
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14252
14511
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14253
14512
|
onProgress(progress: number): void;
|
|
14254
|
-
postProcess():
|
|
14513
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14514
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
14515
|
+
finalize(): void;
|
|
14255
14516
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
14256
14517
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14257
14518
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14258
14519
|
delayRetry(): Promise<void>;
|
|
14259
|
-
divide(): /*elided*/ any[]
|
|
14520
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14521
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
14260
14522
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
14261
14523
|
differentiate(task: Task): /*elided*/ any;
|
|
14262
14524
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -14381,12 +14643,15 @@ declare class CadenzaService {
|
|
|
14381
14643
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14382
14644
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14383
14645
|
onProgress(progress: number): void;
|
|
14384
|
-
postProcess():
|
|
14646
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14647
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
14648
|
+
finalize(): void;
|
|
14385
14649
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
14386
14650
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14387
14651
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14388
14652
|
delayRetry(): Promise<void>;
|
|
14389
|
-
divide(): /*elided*/ any[]
|
|
14653
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14654
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
14390
14655
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
14391
14656
|
differentiate(task: Task): /*elided*/ any;
|
|
14392
14657
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -14510,12 +14775,15 @@ declare class CadenzaService {
|
|
|
14510
14775
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14511
14776
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14512
14777
|
onProgress(progress: number): void;
|
|
14513
|
-
postProcess():
|
|
14778
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14779
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
14780
|
+
finalize(): void;
|
|
14514
14781
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
14515
14782
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14516
14783
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14517
14784
|
delayRetry(): Promise<void>;
|
|
14518
|
-
divide(): /*elided*/ any[]
|
|
14785
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14786
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
14519
14787
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
14520
14788
|
differentiate(task: Task): /*elided*/ any;
|
|
14521
14789
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -14643,12 +14911,15 @@ declare class CadenzaService {
|
|
|
14643
14911
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14644
14912
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14645
14913
|
onProgress(progress: number): void;
|
|
14646
|
-
postProcess():
|
|
14914
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14915
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
14916
|
+
finalize(): void;
|
|
14647
14917
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
14648
14918
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14649
14919
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14650
14920
|
delayRetry(): Promise<void>;
|
|
14651
|
-
divide(): /*elided*/ any[]
|
|
14921
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
14922
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
14652
14923
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
14653
14924
|
differentiate(task: Task): /*elided*/ any;
|
|
14654
14925
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -14788,12 +15059,15 @@ declare class CadenzaService {
|
|
|
14788
15059
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14789
15060
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14790
15061
|
onProgress(progress: number): void;
|
|
14791
|
-
postProcess():
|
|
15062
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15063
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
15064
|
+
finalize(): void;
|
|
14792
15065
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
14793
15066
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14794
15067
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14795
15068
|
delayRetry(): Promise<void>;
|
|
14796
|
-
divide(): /*elided*/ any[]
|
|
15069
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15070
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
14797
15071
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
14798
15072
|
differentiate(task: Task): /*elided*/ any;
|
|
14799
15073
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -14970,12 +15244,15 @@ declare class CadenzaService {
|
|
|
14970
15244
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14971
15245
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
14972
15246
|
onProgress(progress: number): void;
|
|
14973
|
-
postProcess():
|
|
15247
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15248
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
15249
|
+
finalize(): void;
|
|
14974
15250
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
14975
15251
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14976
15252
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
14977
15253
|
delayRetry(): Promise<void>;
|
|
14978
|
-
divide(): /*elided*/ any[]
|
|
15254
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15255
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
14979
15256
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
14980
15257
|
differentiate(task: Task): /*elided*/ any;
|
|
14981
15258
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -15107,12 +15384,15 @@ declare class CadenzaService {
|
|
|
15107
15384
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15108
15385
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15109
15386
|
onProgress(progress: number): void;
|
|
15110
|
-
postProcess():
|
|
15387
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15388
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
15389
|
+
finalize(): void;
|
|
15111
15390
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
15112
15391
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15113
15392
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15114
15393
|
delayRetry(): Promise<void>;
|
|
15115
|
-
divide(): /*elided*/ any[]
|
|
15394
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15395
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
15116
15396
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
15117
15397
|
differentiate(task: Task): /*elided*/ any;
|
|
15118
15398
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -15237,12 +15517,15 @@ declare class CadenzaService {
|
|
|
15237
15517
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15238
15518
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15239
15519
|
onProgress(progress: number): void;
|
|
15240
|
-
postProcess():
|
|
15520
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15521
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
15522
|
+
finalize(): void;
|
|
15241
15523
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
15242
15524
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15243
15525
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15244
15526
|
delayRetry(): Promise<void>;
|
|
15245
|
-
divide(): /*elided*/ any[]
|
|
15527
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15528
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
15246
15529
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
15247
15530
|
differentiate(task: Task): /*elided*/ any;
|
|
15248
15531
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -15366,12 +15649,15 @@ declare class CadenzaService {
|
|
|
15366
15649
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15367
15650
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15368
15651
|
onProgress(progress: number): void;
|
|
15369
|
-
postProcess():
|
|
15652
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15653
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
15654
|
+
finalize(): void;
|
|
15370
15655
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
15371
15656
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15372
15657
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15373
15658
|
delayRetry(): Promise<void>;
|
|
15374
|
-
divide(): /*elided*/ any[]
|
|
15659
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15660
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
15375
15661
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
15376
15662
|
differentiate(task: Task): /*elided*/ any;
|
|
15377
15663
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -15499,12 +15785,15 @@ declare class CadenzaService {
|
|
|
15499
15785
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15500
15786
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15501
15787
|
onProgress(progress: number): void;
|
|
15502
|
-
postProcess():
|
|
15788
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15789
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
15790
|
+
finalize(): void;
|
|
15503
15791
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
15504
15792
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15505
15793
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15506
15794
|
delayRetry(): Promise<void>;
|
|
15507
|
-
divide(): /*elided*/ any[]
|
|
15795
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15796
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
15508
15797
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
15509
15798
|
differentiate(task: Task): /*elided*/ any;
|
|
15510
15799
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -15644,12 +15933,15 @@ declare class CadenzaService {
|
|
|
15644
15933
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15645
15934
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15646
15935
|
onProgress(progress: number): void;
|
|
15647
|
-
postProcess():
|
|
15936
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15937
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
15938
|
+
finalize(): void;
|
|
15648
15939
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
15649
15940
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15650
15941
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15651
15942
|
delayRetry(): Promise<void>;
|
|
15652
|
-
divide(): /*elided*/ any[]
|
|
15943
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
15944
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
15653
15945
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
15654
15946
|
differentiate(task: Task): /*elided*/ any;
|
|
15655
15947
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -15831,12 +16123,15 @@ declare class CadenzaService {
|
|
|
15831
16123
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15832
16124
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15833
16125
|
onProgress(progress: number): void;
|
|
15834
|
-
postProcess():
|
|
16126
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16127
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
16128
|
+
finalize(): void;
|
|
15835
16129
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
15836
16130
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15837
16131
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15838
16132
|
delayRetry(): Promise<void>;
|
|
15839
|
-
divide(): /*elided*/ any[]
|
|
16133
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16134
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
15840
16135
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
15841
16136
|
differentiate(task: Task): /*elided*/ any;
|
|
15842
16137
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -15968,12 +16263,15 @@ declare class CadenzaService {
|
|
|
15968
16263
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15969
16264
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
15970
16265
|
onProgress(progress: number): void;
|
|
15971
|
-
postProcess():
|
|
16266
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16267
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
16268
|
+
finalize(): void;
|
|
15972
16269
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
15973
16270
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15974
16271
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
15975
16272
|
delayRetry(): Promise<void>;
|
|
15976
|
-
divide(): /*elided*/ any[]
|
|
16273
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16274
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
15977
16275
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
15978
16276
|
differentiate(task: Task): /*elided*/ any;
|
|
15979
16277
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -16098,12 +16396,15 @@ declare class CadenzaService {
|
|
|
16098
16396
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16099
16397
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16100
16398
|
onProgress(progress: number): void;
|
|
16101
|
-
postProcess():
|
|
16399
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16400
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
16401
|
+
finalize(): void;
|
|
16102
16402
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
16103
16403
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16104
16404
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16105
16405
|
delayRetry(): Promise<void>;
|
|
16106
|
-
divide(): /*elided*/ any[]
|
|
16406
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16407
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
16107
16408
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
16108
16409
|
differentiate(task: Task): /*elided*/ any;
|
|
16109
16410
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -16227,12 +16528,15 @@ declare class CadenzaService {
|
|
|
16227
16528
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16228
16529
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16229
16530
|
onProgress(progress: number): void;
|
|
16230
|
-
postProcess():
|
|
16531
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16532
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
16533
|
+
finalize(): void;
|
|
16231
16534
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
16232
16535
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16233
16536
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16234
16537
|
delayRetry(): Promise<void>;
|
|
16235
|
-
divide(): /*elided*/ any[]
|
|
16538
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16539
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
16236
16540
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
16237
16541
|
differentiate(task: Task): /*elided*/ any;
|
|
16238
16542
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -16360,12 +16664,15 @@ declare class CadenzaService {
|
|
|
16360
16664
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16361
16665
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16362
16666
|
onProgress(progress: number): void;
|
|
16363
|
-
postProcess():
|
|
16667
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16668
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
16669
|
+
finalize(): void;
|
|
16364
16670
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
16365
16671
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16366
16672
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16367
16673
|
delayRetry(): Promise<void>;
|
|
16368
|
-
divide(): /*elided*/ any[]
|
|
16674
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16675
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
16369
16676
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
16370
16677
|
differentiate(task: Task): /*elided*/ any;
|
|
16371
16678
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -16505,12 +16812,15 @@ declare class CadenzaService {
|
|
|
16505
16812
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16506
16813
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16507
16814
|
onProgress(progress: number): void;
|
|
16508
|
-
postProcess():
|
|
16815
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16816
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
16817
|
+
finalize(): void;
|
|
16509
16818
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
16510
16819
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16511
16820
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16512
16821
|
delayRetry(): Promise<void>;
|
|
16513
|
-
divide(): /*elided*/ any[]
|
|
16822
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
16823
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
16514
16824
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
16515
16825
|
differentiate(task: Task): /*elided*/ any;
|
|
16516
16826
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -16688,12 +16998,15 @@ declare class CadenzaService {
|
|
|
16688
16998
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16689
16999
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16690
17000
|
onProgress(progress: number): void;
|
|
16691
|
-
postProcess():
|
|
17001
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17002
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
17003
|
+
finalize(): void;
|
|
16692
17004
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
16693
17005
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16694
17006
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16695
17007
|
delayRetry(): Promise<void>;
|
|
16696
|
-
divide(): /*elided*/ any[]
|
|
17008
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17009
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
16697
17010
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
16698
17011
|
differentiate(task: Task): /*elided*/ any;
|
|
16699
17012
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -16825,12 +17138,15 @@ declare class CadenzaService {
|
|
|
16825
17138
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16826
17139
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16827
17140
|
onProgress(progress: number): void;
|
|
16828
|
-
postProcess():
|
|
17141
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17142
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
17143
|
+
finalize(): void;
|
|
16829
17144
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
16830
17145
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16831
17146
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16832
17147
|
delayRetry(): Promise<void>;
|
|
16833
|
-
divide(): /*elided*/ any[]
|
|
17148
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17149
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
16834
17150
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
16835
17151
|
differentiate(task: Task): /*elided*/ any;
|
|
16836
17152
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -16955,12 +17271,15 @@ declare class CadenzaService {
|
|
|
16955
17271
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16956
17272
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
16957
17273
|
onProgress(progress: number): void;
|
|
16958
|
-
postProcess():
|
|
17274
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17275
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
17276
|
+
finalize(): void;
|
|
16959
17277
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
16960
17278
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16961
17279
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
16962
17280
|
delayRetry(): Promise<void>;
|
|
16963
|
-
divide(): /*elided*/ any[]
|
|
17281
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17282
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
16964
17283
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
16965
17284
|
differentiate(task: Task): /*elided*/ any;
|
|
16966
17285
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -17084,12 +17403,15 @@ declare class CadenzaService {
|
|
|
17084
17403
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17085
17404
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17086
17405
|
onProgress(progress: number): void;
|
|
17087
|
-
postProcess():
|
|
17406
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17407
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
17408
|
+
finalize(): void;
|
|
17088
17409
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
17089
17410
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17090
17411
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17091
17412
|
delayRetry(): Promise<void>;
|
|
17092
|
-
divide(): /*elided*/ any[]
|
|
17413
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17414
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
17093
17415
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
17094
17416
|
differentiate(task: Task): /*elided*/ any;
|
|
17095
17417
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -17217,12 +17539,15 @@ declare class CadenzaService {
|
|
|
17217
17539
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17218
17540
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17219
17541
|
onProgress(progress: number): void;
|
|
17220
|
-
postProcess():
|
|
17542
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17543
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
17544
|
+
finalize(): void;
|
|
17221
17545
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
17222
17546
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17223
17547
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17224
17548
|
delayRetry(): Promise<void>;
|
|
17225
|
-
divide(): /*elided*/ any[]
|
|
17549
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17550
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
17226
17551
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
17227
17552
|
differentiate(task: Task): /*elided*/ any;
|
|
17228
17553
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -17362,12 +17687,15 @@ declare class CadenzaService {
|
|
|
17362
17687
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17363
17688
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17364
17689
|
onProgress(progress: number): void;
|
|
17365
|
-
postProcess():
|
|
17690
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17691
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
17692
|
+
finalize(): void;
|
|
17366
17693
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
17367
17694
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17368
17695
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17369
17696
|
delayRetry(): Promise<void>;
|
|
17370
|
-
divide(): /*elided*/ any[]
|
|
17697
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17698
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
17371
17699
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
17372
17700
|
differentiate(task: Task): /*elided*/ any;
|
|
17373
17701
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -17546,12 +17874,15 @@ declare class CadenzaService {
|
|
|
17546
17874
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17547
17875
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17548
17876
|
onProgress(progress: number): void;
|
|
17549
|
-
postProcess():
|
|
17877
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17878
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
17879
|
+
finalize(): void;
|
|
17550
17880
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
17551
17881
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17552
17882
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17553
17883
|
delayRetry(): Promise<void>;
|
|
17554
|
-
divide(): /*elided*/ any[]
|
|
17884
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
17885
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
17555
17886
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
17556
17887
|
differentiate(task: Task): /*elided*/ any;
|
|
17557
17888
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -17683,12 +18014,15 @@ declare class CadenzaService {
|
|
|
17683
18014
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17684
18015
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17685
18016
|
onProgress(progress: number): void;
|
|
17686
|
-
postProcess():
|
|
18017
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18018
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
18019
|
+
finalize(): void;
|
|
17687
18020
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
17688
18021
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17689
18022
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17690
18023
|
delayRetry(): Promise<void>;
|
|
17691
|
-
divide(): /*elided*/ any[]
|
|
18024
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18025
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
17692
18026
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
17693
18027
|
differentiate(task: Task): /*elided*/ any;
|
|
17694
18028
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -17813,12 +18147,15 @@ declare class CadenzaService {
|
|
|
17813
18147
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17814
18148
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17815
18149
|
onProgress(progress: number): void;
|
|
17816
|
-
postProcess():
|
|
18150
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18151
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
18152
|
+
finalize(): void;
|
|
17817
18153
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
17818
18154
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17819
18155
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17820
18156
|
delayRetry(): Promise<void>;
|
|
17821
|
-
divide(): /*elided*/ any[]
|
|
18157
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18158
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
17822
18159
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
17823
18160
|
differentiate(task: Task): /*elided*/ any;
|
|
17824
18161
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -17942,12 +18279,15 @@ declare class CadenzaService {
|
|
|
17942
18279
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17943
18280
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
17944
18281
|
onProgress(progress: number): void;
|
|
17945
|
-
postProcess():
|
|
18282
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18283
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
18284
|
+
finalize(): void;
|
|
17946
18285
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
17947
18286
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17948
18287
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
17949
18288
|
delayRetry(): Promise<void>;
|
|
17950
|
-
divide(): /*elided*/ any[]
|
|
18289
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18290
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
17951
18291
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
17952
18292
|
differentiate(task: Task): /*elided*/ any;
|
|
17953
18293
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -18075,12 +18415,15 @@ declare class CadenzaService {
|
|
|
18075
18415
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
18076
18416
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
18077
18417
|
onProgress(progress: number): void;
|
|
18078
|
-
postProcess():
|
|
18418
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18419
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
18420
|
+
finalize(): void;
|
|
18079
18421
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
18080
18422
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
18081
18423
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
18082
18424
|
delayRetry(): Promise<void>;
|
|
18083
|
-
divide(): /*elided*/ any[]
|
|
18425
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18426
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
18084
18427
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
18085
18428
|
differentiate(task: Task): /*elided*/ any;
|
|
18086
18429
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -18220,12 +18563,15 @@ declare class CadenzaService {
|
|
|
18220
18563
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
18221
18564
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
18222
18565
|
onProgress(progress: number): void;
|
|
18223
|
-
postProcess():
|
|
18566
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18567
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
18568
|
+
finalize(): void;
|
|
18224
18569
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
18225
18570
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
18226
18571
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
18227
18572
|
delayRetry(): Promise<void>;
|
|
18228
|
-
divide(): /*elided*/ any[]
|
|
18573
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18574
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
18229
18575
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
18230
18576
|
differentiate(task: Task): /*elided*/ any;
|
|
18231
18577
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -18571,12 +18917,15 @@ declare class CadenzaService {
|
|
|
18571
18917
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
18572
18918
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
18573
18919
|
onProgress(progress: number): void;
|
|
18574
|
-
postProcess():
|
|
18920
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18921
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
18922
|
+
finalize(): void;
|
|
18575
18923
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
18576
18924
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
18577
18925
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
18578
18926
|
delayRetry(): Promise<void>;
|
|
18579
|
-
divide(): /*elided*/ any[]
|
|
18927
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
18928
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
18580
18929
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
18581
18930
|
differentiate(task: Task): /*elided*/ any;
|
|
18582
18931
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -18952,12 +19301,15 @@ declare class CadenzaService {
|
|
|
18952
19301
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
18953
19302
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
18954
19303
|
onProgress(progress: number): void;
|
|
18955
|
-
postProcess():
|
|
19304
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19305
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
19306
|
+
finalize(): void;
|
|
18956
19307
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
18957
19308
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
18958
19309
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
18959
19310
|
delayRetry(): Promise<void>;
|
|
18960
|
-
divide(): /*elided*/ any[]
|
|
19311
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19312
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
18961
19313
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
18962
19314
|
differentiate(task: Task): /*elided*/ any;
|
|
18963
19315
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -19166,12 +19518,15 @@ declare class CadenzaService {
|
|
|
19166
19518
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19167
19519
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19168
19520
|
onProgress(progress: number): void;
|
|
19169
|
-
postProcess():
|
|
19521
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19522
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
19523
|
+
finalize(): void;
|
|
19170
19524
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
19171
19525
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19172
19526
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19173
19527
|
delayRetry(): Promise<void>;
|
|
19174
|
-
divide(): /*elided*/ any[]
|
|
19528
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19529
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
19175
19530
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
19176
19531
|
differentiate(task: Task): /*elided*/ any;
|
|
19177
19532
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -19303,12 +19658,15 @@ declare class CadenzaService {
|
|
|
19303
19658
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19304
19659
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19305
19660
|
onProgress(progress: number): void;
|
|
19306
|
-
postProcess():
|
|
19661
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19662
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
19663
|
+
finalize(): void;
|
|
19307
19664
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
19308
19665
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19309
19666
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19310
19667
|
delayRetry(): Promise<void>;
|
|
19311
|
-
divide(): /*elided*/ any[]
|
|
19668
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19669
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
19312
19670
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
19313
19671
|
differentiate(task: Task): /*elided*/ any;
|
|
19314
19672
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -19433,12 +19791,15 @@ declare class CadenzaService {
|
|
|
19433
19791
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19434
19792
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19435
19793
|
onProgress(progress: number): void;
|
|
19436
|
-
postProcess():
|
|
19794
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19795
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
19796
|
+
finalize(): void;
|
|
19437
19797
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
19438
19798
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19439
19799
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19440
19800
|
delayRetry(): Promise<void>;
|
|
19441
|
-
divide(): /*elided*/ any[]
|
|
19801
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19802
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
19442
19803
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
19443
19804
|
differentiate(task: Task): /*elided*/ any;
|
|
19444
19805
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -19562,12 +19923,15 @@ declare class CadenzaService {
|
|
|
19562
19923
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19563
19924
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19564
19925
|
onProgress(progress: number): void;
|
|
19565
|
-
postProcess():
|
|
19926
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19927
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
19928
|
+
finalize(): void;
|
|
19566
19929
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
19567
19930
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19568
19931
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19569
19932
|
delayRetry(): Promise<void>;
|
|
19570
|
-
divide(): /*elided*/ any[]
|
|
19933
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
19934
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
19571
19935
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
19572
19936
|
differentiate(task: Task): /*elided*/ any;
|
|
19573
19937
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -19695,12 +20059,15 @@ declare class CadenzaService {
|
|
|
19695
20059
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19696
20060
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19697
20061
|
onProgress(progress: number): void;
|
|
19698
|
-
postProcess():
|
|
20062
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20063
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
20064
|
+
finalize(): void;
|
|
19699
20065
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
19700
20066
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19701
20067
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19702
20068
|
delayRetry(): Promise<void>;
|
|
19703
|
-
divide(): /*elided*/ any[]
|
|
20069
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20070
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
19704
20071
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
19705
20072
|
differentiate(task: Task): /*elided*/ any;
|
|
19706
20073
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -19840,12 +20207,15 @@ declare class CadenzaService {
|
|
|
19840
20207
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19841
20208
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
19842
20209
|
onProgress(progress: number): void;
|
|
19843
|
-
postProcess():
|
|
20210
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20211
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
20212
|
+
finalize(): void;
|
|
19844
20213
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
19845
20214
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19846
20215
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
19847
20216
|
delayRetry(): Promise<void>;
|
|
19848
|
-
divide(): /*elided*/ any[]
|
|
20217
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20218
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
19849
20219
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
19850
20220
|
differentiate(task: Task): /*elided*/ any;
|
|
19851
20221
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -20022,12 +20392,15 @@ declare class CadenzaService {
|
|
|
20022
20392
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20023
20393
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20024
20394
|
onProgress(progress: number): void;
|
|
20025
|
-
postProcess():
|
|
20395
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20396
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
20397
|
+
finalize(): void;
|
|
20026
20398
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
20027
20399
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20028
20400
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20029
20401
|
delayRetry(): Promise<void>;
|
|
20030
|
-
divide(): /*elided*/ any[]
|
|
20402
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20403
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
20031
20404
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
20032
20405
|
differentiate(task: Task): /*elided*/ any;
|
|
20033
20406
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -20159,12 +20532,15 @@ declare class CadenzaService {
|
|
|
20159
20532
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20160
20533
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20161
20534
|
onProgress(progress: number): void;
|
|
20162
|
-
postProcess():
|
|
20535
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20536
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
20537
|
+
finalize(): void;
|
|
20163
20538
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
20164
20539
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20165
20540
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20166
20541
|
delayRetry(): Promise<void>;
|
|
20167
|
-
divide(): /*elided*/ any[]
|
|
20542
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20543
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
20168
20544
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
20169
20545
|
differentiate(task: Task): /*elided*/ any;
|
|
20170
20546
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -20289,12 +20665,15 @@ declare class CadenzaService {
|
|
|
20289
20665
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20290
20666
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20291
20667
|
onProgress(progress: number): void;
|
|
20292
|
-
postProcess():
|
|
20668
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20669
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
20670
|
+
finalize(): void;
|
|
20293
20671
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
20294
20672
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20295
20673
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20296
20674
|
delayRetry(): Promise<void>;
|
|
20297
|
-
divide(): /*elided*/ any[]
|
|
20675
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20676
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
20298
20677
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
20299
20678
|
differentiate(task: Task): /*elided*/ any;
|
|
20300
20679
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -20418,12 +20797,15 @@ declare class CadenzaService {
|
|
|
20418
20797
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20419
20798
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20420
20799
|
onProgress(progress: number): void;
|
|
20421
|
-
postProcess():
|
|
20800
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20801
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
20802
|
+
finalize(): void;
|
|
20422
20803
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
20423
20804
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20424
20805
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20425
20806
|
delayRetry(): Promise<void>;
|
|
20426
|
-
divide(): /*elided*/ any[]
|
|
20807
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20808
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
20427
20809
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
20428
20810
|
differentiate(task: Task): /*elided*/ any;
|
|
20429
20811
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -20551,12 +20933,15 @@ declare class CadenzaService {
|
|
|
20551
20933
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20552
20934
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20553
20935
|
onProgress(progress: number): void;
|
|
20554
|
-
postProcess():
|
|
20936
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20937
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
20938
|
+
finalize(): void;
|
|
20555
20939
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
20556
20940
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20557
20941
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20558
20942
|
delayRetry(): Promise<void>;
|
|
20559
|
-
divide(): /*elided*/ any[]
|
|
20943
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
20944
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
20560
20945
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
20561
20946
|
differentiate(task: Task): /*elided*/ any;
|
|
20562
20947
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -20696,12 +21081,15 @@ declare class CadenzaService {
|
|
|
20696
21081
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20697
21082
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
20698
21083
|
onProgress(progress: number): void;
|
|
20699
|
-
postProcess():
|
|
21084
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
21085
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
21086
|
+
finalize(): void;
|
|
20700
21087
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
20701
21088
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20702
21089
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
20703
21090
|
delayRetry(): Promise<void>;
|
|
20704
|
-
divide(): /*elided*/ any[]
|
|
21091
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
21092
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
20705
21093
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
20706
21094
|
differentiate(task: Task): /*elided*/ any;
|
|
20707
21095
|
migrate(ctx: any): /*elided*/ any;
|
|
@@ -21049,12 +21437,15 @@ declare class CadenzaService {
|
|
|
21049
21437
|
emitWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
21050
21438
|
emitMetricsWithMetadata(signal: string, ctx: _cadenza_io_core.AnyObject): void;
|
|
21051
21439
|
onProgress(progress: number): void;
|
|
21052
|
-
postProcess():
|
|
21440
|
+
postProcess(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
21441
|
+
postProcessAsync(nextNodes: Promise</*elided*/ any[]>): Promise</*elided*/ any[]>;
|
|
21442
|
+
finalize(): void;
|
|
21053
21443
|
onError(error: unknown, errorData?: _cadenza_io_core.AnyObject): void;
|
|
21054
21444
|
retry(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
21055
21445
|
retryAsync(prevResult?: any): Promise<_cadenza_io_core.TaskResult>;
|
|
21056
21446
|
delayRetry(): Promise<void>;
|
|
21057
|
-
divide(): /*elided*/ any[]
|
|
21447
|
+
divide(): /*elided*/ any[] | Promise</*elided*/ any[]>;
|
|
21448
|
+
divideAsync(current: Promise<IteratorResult<any>>): Promise</*elided*/ any[]>;
|
|
21058
21449
|
generateNewNodes(result: any): /*elided*/ any[];
|
|
21059
21450
|
differentiate(task: Task): /*elided*/ any;
|
|
21060
21451
|
migrate(ctx: any): /*elided*/ any;
|