@xyo-network/diviner-temporal-indexing 7.2.3 → 7.3.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/neutral/index.d.ts +2 -2
- package/dist/neutral/index.d.ts.map +1 -1
- package/dist/neutral/index.mjs +545 -3
- package/dist/neutral/index.mjs.map +4 -4
- package/dist/neutral/memory/Diviner.d.ts +10 -0
- package/dist/neutral/memory/Diviner.d.ts.map +1 -0
- package/dist/neutral/memory/DivinerQueryToIndexQueryDiviner/Diviner.d.ts +43 -0
- package/dist/neutral/memory/DivinerQueryToIndexQueryDiviner/Diviner.d.ts.map +1 -0
- package/dist/neutral/memory/DivinerQueryToIndexQueryDiviner/index.d.ts +2 -0
- package/dist/neutral/memory/DivinerQueryToIndexQueryDiviner/index.d.ts.map +1 -0
- package/dist/neutral/memory/IndexCandidateToIndexDiviner/Diviner.d.ts +45 -0
- package/dist/neutral/memory/IndexCandidateToIndexDiviner/Diviner.d.ts.map +1 -0
- package/dist/neutral/memory/IndexCandidateToIndexDiviner/index.d.ts +2 -0
- package/dist/neutral/memory/IndexCandidateToIndexDiviner/index.d.ts.map +1 -0
- package/dist/neutral/memory/IndexQueryResponseToDivinerQueryResponseDiviner/Diviner.d.ts +13 -0
- package/dist/neutral/memory/IndexQueryResponseToDivinerQueryResponseDiviner/Diviner.d.ts.map +1 -0
- package/dist/neutral/memory/IndexQueryResponseToDivinerQueryResponseDiviner/index.d.ts +2 -0
- package/dist/neutral/memory/IndexQueryResponseToDivinerQueryResponseDiviner/index.d.ts.map +1 -0
- package/dist/neutral/memory/StateToIndexCandidateDiviner/Diviner.d.ts +54 -0
- package/dist/neutral/memory/StateToIndexCandidateDiviner/Diviner.d.ts.map +1 -0
- package/dist/neutral/memory/StateToIndexCandidateDiviner/index.d.ts +2 -0
- package/dist/neutral/memory/StateToIndexCandidateDiviner/index.d.ts.map +1 -0
- package/dist/neutral/memory/index.d.ts +6 -0
- package/dist/neutral/memory/index.d.ts.map +1 -0
- package/dist/neutral/memory.d.ts +2 -0
- package/dist/neutral/memory.d.ts.map +1 -0
- package/dist/neutral/memory.mjs +470 -0
- package/dist/neutral/memory.mjs.map +7 -0
- package/dist/neutral/model/Config.d.ts +74 -0
- package/dist/neutral/model/Config.d.ts.map +1 -0
- package/dist/neutral/model/DivinerQueryToIndexQueryDiviner/Config.d.ts +47 -0
- package/dist/neutral/model/DivinerQueryToIndexQueryDiviner/Config.d.ts.map +1 -0
- package/dist/neutral/model/DivinerQueryToIndexQueryDiviner/Params.d.ts +5 -0
- package/dist/neutral/model/DivinerQueryToIndexQueryDiviner/Params.d.ts.map +1 -0
- package/dist/neutral/model/DivinerQueryToIndexQueryDiviner/Schema.d.ts +5 -0
- package/dist/neutral/model/DivinerQueryToIndexQueryDiviner/Schema.d.ts.map +1 -0
- package/dist/neutral/model/DivinerQueryToIndexQueryDiviner/index.d.ts +4 -0
- package/dist/neutral/model/DivinerQueryToIndexQueryDiviner/index.d.ts.map +1 -0
- package/dist/neutral/model/IndexCandidateToIndexDiviner/Config.d.ts +31 -0
- package/dist/neutral/model/IndexCandidateToIndexDiviner/Config.d.ts.map +1 -0
- package/dist/neutral/model/IndexCandidateToIndexDiviner/Params.d.ts +8 -0
- package/dist/neutral/model/IndexCandidateToIndexDiviner/Params.d.ts.map +1 -0
- package/dist/neutral/model/IndexCandidateToIndexDiviner/Schema.d.ts +5 -0
- package/dist/neutral/model/IndexCandidateToIndexDiviner/Schema.d.ts.map +1 -0
- package/dist/neutral/model/IndexCandidateToIndexDiviner/index.d.ts +4 -0
- package/dist/neutral/model/IndexCandidateToIndexDiviner/index.d.ts.map +1 -0
- package/dist/neutral/model/IndexQueryResponseToDivinerQueryResponseDiviner/Config.d.ts +31 -0
- package/dist/neutral/model/IndexQueryResponseToDivinerQueryResponseDiviner/Config.d.ts.map +1 -0
- package/dist/neutral/model/IndexQueryResponseToDivinerQueryResponseDiviner/Params.d.ts +5 -0
- package/dist/neutral/model/IndexQueryResponseToDivinerQueryResponseDiviner/Params.d.ts.map +1 -0
- package/dist/neutral/model/IndexQueryResponseToDivinerQueryResponseDiviner/Schema.d.ts +5 -0
- package/dist/neutral/model/IndexQueryResponseToDivinerQueryResponseDiviner/Schema.d.ts.map +1 -0
- package/dist/neutral/model/IndexQueryResponseToDivinerQueryResponseDiviner/index.d.ts +4 -0
- package/dist/neutral/model/IndexQueryResponseToDivinerQueryResponseDiviner/index.d.ts.map +1 -0
- package/dist/neutral/model/Params.d.ts +5 -0
- package/dist/neutral/model/Params.d.ts.map +1 -0
- package/dist/neutral/model/Result/Payload.d.ts +14 -0
- package/dist/neutral/model/Result/Payload.d.ts.map +1 -0
- package/dist/neutral/model/Result/Schema.d.ts +5 -0
- package/dist/neutral/model/Result/Schema.d.ts.map +1 -0
- package/dist/neutral/model/Result/index.d.ts +3 -0
- package/dist/neutral/model/Result/index.d.ts.map +1 -0
- package/dist/neutral/model/ResultIndex/Payload.d.ts +14 -0
- package/dist/neutral/model/ResultIndex/Payload.d.ts.map +1 -0
- package/dist/neutral/model/ResultIndex/Schema.d.ts +5 -0
- package/dist/neutral/model/ResultIndex/Schema.d.ts.map +1 -0
- package/dist/neutral/model/ResultIndex/index.d.ts +3 -0
- package/dist/neutral/model/ResultIndex/index.d.ts.map +1 -0
- package/dist/neutral/model/Schema.d.ts +5 -0
- package/dist/neutral/model/Schema.d.ts.map +1 -0
- package/dist/neutral/model/StateToIndexCandidateDiviner/Config.d.ts +41 -0
- package/dist/neutral/model/StateToIndexCandidateDiviner/Config.d.ts.map +1 -0
- package/dist/neutral/model/StateToIndexCandidateDiviner/Params.d.ts +5 -0
- package/dist/neutral/model/StateToIndexCandidateDiviner/Params.d.ts.map +1 -0
- package/dist/neutral/model/StateToIndexCandidateDiviner/Schema.d.ts +5 -0
- package/dist/neutral/model/StateToIndexCandidateDiviner/Schema.d.ts.map +1 -0
- package/dist/neutral/model/StateToIndexCandidateDiviner/index.d.ts +4 -0
- package/dist/neutral/model/StateToIndexCandidateDiviner/index.d.ts.map +1 -0
- package/dist/neutral/model/index.d.ts +10 -0
- package/dist/neutral/model/index.d.ts.map +1 -0
- package/dist/neutral/model.d.ts +2 -0
- package/dist/neutral/model.d.ts.map +1 -0
- package/dist/neutral/model.mjs +242 -0
- package/dist/neutral/model.mjs.map +7 -0
- package/package.json +27 -8
package/dist/neutral/index.d.ts
CHANGED
|
@@ -1,3 +1,3 @@
|
|
|
1
|
-
export * from '
|
|
2
|
-
export * from '
|
|
1
|
+
export * from './memory.ts';
|
|
2
|
+
export * from './model.ts';
|
|
3
3
|
//# sourceMappingURL=index.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA"}
|
package/dist/neutral/index.mjs
CHANGED
|
@@ -1,4 +1,546 @@
|
|
|
1
|
-
// src/
|
|
2
|
-
|
|
3
|
-
|
|
1
|
+
// src/memory/Diviner.ts
|
|
2
|
+
import { IndexingDiviner } from "@xyo-network/diviner-indexing/memory";
|
|
3
|
+
|
|
4
|
+
// src/model/Config.ts
|
|
5
|
+
import {
|
|
6
|
+
zodAsFactory,
|
|
7
|
+
zodIsFactory,
|
|
8
|
+
zodToFactory
|
|
9
|
+
} from "@ariestools/sdk";
|
|
10
|
+
import { DivinerConfigZod } from "@xyo-network/sdk/diviner-model";
|
|
11
|
+
import { asSchema as asSchema2 } from "@xyo-network/sdk-protocol";
|
|
12
|
+
import * as z from "zod/mini";
|
|
13
|
+
|
|
14
|
+
// src/model/Schema.ts
|
|
15
|
+
import { IndexingDivinerSchema } from "@xyo-network/diviner-indexing/model";
|
|
16
|
+
import { asSchema } from "@xyo-network/sdk-protocol";
|
|
17
|
+
var TemporalIndexingDivinerSchema = asSchema(`${IndexingDivinerSchema}.temporal`, true);
|
|
18
|
+
|
|
19
|
+
// src/model/Config.ts
|
|
20
|
+
var TemporalIndexingDivinerConfigSchema = asSchema2(`${TemporalIndexingDivinerSchema}.config`, true);
|
|
21
|
+
var TemporalIndexingDivinerConfigZod = z.extend(DivinerConfigZod, {
|
|
22
|
+
indexStore: z.optional(z.custom()),
|
|
23
|
+
indexingDivinerStages: z.optional(z.custom()),
|
|
24
|
+
payloadDivinerLimit: z.optional(z.number()),
|
|
25
|
+
pollFrequency: z.optional(z.number()),
|
|
26
|
+
schema: z.literal(TemporalIndexingDivinerConfigSchema),
|
|
27
|
+
stageConfigs: z.optional(z.object({
|
|
28
|
+
divinerQueryToIndexQueryDiviner: z.optional(z.custom()),
|
|
29
|
+
indexCandidateToIndexDiviner: z.optional(z.custom()),
|
|
30
|
+
indexQueryResponseToDivinerQueryResponseDiviner: z.optional(
|
|
31
|
+
z.custom()
|
|
32
|
+
),
|
|
33
|
+
stateToIndexCandidateDiviner: z.optional(z.custom())
|
|
34
|
+
})),
|
|
35
|
+
stateStore: z.optional(z.custom())
|
|
36
|
+
});
|
|
37
|
+
var isTemporalIndexingDivinerConfig = zodIsFactory(TemporalIndexingDivinerConfigZod);
|
|
38
|
+
var asTemporalIndexingDivinerConfig = zodAsFactory(TemporalIndexingDivinerConfigZod, "asTemporalIndexingDivinerConfig");
|
|
39
|
+
var toTemporalIndexingDivinerConfig = zodToFactory(TemporalIndexingDivinerConfigZod, "toTemporalIndexingDivinerConfig");
|
|
40
|
+
|
|
41
|
+
// src/model/DivinerQueryToIndexQueryDiviner/Config.ts
|
|
42
|
+
import {
|
|
43
|
+
zodAsFactory as zodAsFactory2,
|
|
44
|
+
zodIsFactory as zodIsFactory2,
|
|
45
|
+
zodToFactory as zodToFactory2
|
|
46
|
+
} from "@ariestools/sdk";
|
|
47
|
+
import { DivinerConfigZod as DivinerConfigZod2 } from "@xyo-network/sdk/diviner-model";
|
|
48
|
+
import { asSchema as asSchema4 } from "@xyo-network/sdk-protocol";
|
|
49
|
+
import * as z2 from "zod/mini";
|
|
50
|
+
|
|
51
|
+
// src/model/DivinerQueryToIndexQueryDiviner/Schema.ts
|
|
52
|
+
import { asSchema as asSchema3 } from "@xyo-network/sdk-protocol";
|
|
53
|
+
var TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerSchema = asSchema3(`${TemporalIndexingDivinerSchema}.stage.diviner.query.to.index.query.diviner`, true);
|
|
54
|
+
|
|
55
|
+
// src/model/DivinerQueryToIndexQueryDiviner/Config.ts
|
|
56
|
+
var TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema = asSchema4(`${TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerSchema}.config`, true);
|
|
57
|
+
var TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigZod = z2.extend(DivinerConfigZod2, {
|
|
58
|
+
divinerQuerySchema: z2.optional(z2.custom()),
|
|
59
|
+
indexQuerySchema: z2.optional(z2.custom()),
|
|
60
|
+
indexSchema: z2.optional(z2.custom()),
|
|
61
|
+
schema: z2.literal(TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema),
|
|
62
|
+
schemaTransforms: z2.optional(z2.custom())
|
|
63
|
+
});
|
|
64
|
+
var isTemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig = zodIsFactory2(TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigZod);
|
|
65
|
+
var asTemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig = zodAsFactory2(
|
|
66
|
+
TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigZod,
|
|
67
|
+
"asTemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig"
|
|
68
|
+
);
|
|
69
|
+
var toTemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig = zodToFactory2(
|
|
70
|
+
TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigZod,
|
|
71
|
+
"toTemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig"
|
|
72
|
+
);
|
|
73
|
+
|
|
74
|
+
// src/model/IndexCandidateToIndexDiviner/Config.ts
|
|
75
|
+
import {
|
|
76
|
+
zodAsFactory as zodAsFactory3,
|
|
77
|
+
zodIsFactory as zodIsFactory3,
|
|
78
|
+
zodToFactory as zodToFactory3
|
|
79
|
+
} from "@ariestools/sdk";
|
|
80
|
+
import { DivinerConfigZod as DivinerConfigZod3 } from "@xyo-network/sdk/diviner-model";
|
|
81
|
+
import { asSchema as asSchema6 } from "@xyo-network/sdk-protocol";
|
|
82
|
+
import * as z3 from "zod/mini";
|
|
83
|
+
|
|
84
|
+
// src/model/IndexCandidateToIndexDiviner/Schema.ts
|
|
85
|
+
import { asSchema as asSchema5 } from "@xyo-network/sdk-protocol";
|
|
86
|
+
var TemporalIndexingDivinerIndexCandidateToIndexDivinerSchema = asSchema5(`${TemporalIndexingDivinerSchema}.stage.index.candidate.to.index.diviner`, true);
|
|
87
|
+
|
|
88
|
+
// src/model/IndexCandidateToIndexDiviner/Config.ts
|
|
89
|
+
var TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema = asSchema6(`${TemporalIndexingDivinerIndexCandidateToIndexDivinerSchema}.config`, true);
|
|
90
|
+
var TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigZod = z3.extend(DivinerConfigZod3, {
|
|
91
|
+
schema: z3.literal(TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema),
|
|
92
|
+
schemaTransforms: z3.optional(z3.custom())
|
|
93
|
+
});
|
|
94
|
+
var isTemporalIndexingDivinerIndexCandidateToIndexDivinerConfig = zodIsFactory3(TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigZod);
|
|
95
|
+
var asTemporalIndexingDivinerIndexCandidateToIndexDivinerConfig = zodAsFactory3(TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigZod, "asTemporalIndexingDivinerIndexCandidateToIndexDivinerConfig");
|
|
96
|
+
var toTemporalIndexingDivinerIndexCandidateToIndexDivinerConfig = zodToFactory3(TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigZod, "toTemporalIndexingDivinerIndexCandidateToIndexDivinerConfig");
|
|
97
|
+
|
|
98
|
+
// src/model/IndexQueryResponseToDivinerQueryResponseDiviner/Config.ts
|
|
99
|
+
import {
|
|
100
|
+
zodAsFactory as zodAsFactory4,
|
|
101
|
+
zodIsFactory as zodIsFactory4,
|
|
102
|
+
zodToFactory as zodToFactory4
|
|
103
|
+
} from "@ariestools/sdk";
|
|
104
|
+
import { DivinerConfigZod as DivinerConfigZod4 } from "@xyo-network/sdk/diviner-model";
|
|
105
|
+
import { asSchema as asSchema8 } from "@xyo-network/sdk-protocol";
|
|
106
|
+
import * as z4 from "zod/mini";
|
|
107
|
+
|
|
108
|
+
// src/model/IndexQueryResponseToDivinerQueryResponseDiviner/Schema.ts
|
|
109
|
+
import { asSchema as asSchema7 } from "@xyo-network/sdk-protocol";
|
|
110
|
+
var TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerSchema = asSchema7(`${TemporalIndexingDivinerSchema}.stage.index.query.response.to.diviner.query.response.diviner`, true);
|
|
111
|
+
|
|
112
|
+
// src/model/IndexQueryResponseToDivinerQueryResponseDiviner/Config.ts
|
|
113
|
+
var TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigSchema = asSchema8(`${TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerSchema}.config`, true);
|
|
114
|
+
var TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigZod = z4.extend(DivinerConfigZod4, {
|
|
115
|
+
schema: z4.literal(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigSchema),
|
|
116
|
+
schemaTransforms: z4.optional(z4.custom())
|
|
117
|
+
});
|
|
118
|
+
var isTemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfig = zodIsFactory4(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigZod);
|
|
119
|
+
var asTemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfig = zodAsFactory4(
|
|
120
|
+
TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigZod,
|
|
121
|
+
"asTemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfig"
|
|
122
|
+
);
|
|
123
|
+
var toTemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfig = zodToFactory4(
|
|
124
|
+
TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigZod,
|
|
125
|
+
"toTemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfig"
|
|
126
|
+
);
|
|
127
|
+
|
|
128
|
+
// src/model/Result/Payload.ts
|
|
129
|
+
import {
|
|
130
|
+
zodAsFactory as zodAsFactory5,
|
|
131
|
+
zodIsFactory as zodIsFactory5,
|
|
132
|
+
zodToFactory as zodToFactory5
|
|
133
|
+
} from "@ariestools/sdk";
|
|
134
|
+
import { PayloadZodOfSchema } from "@xyo-network/sdk-protocol";
|
|
135
|
+
import * as z5 from "zod/mini";
|
|
136
|
+
|
|
137
|
+
// src/model/Result/Schema.ts
|
|
138
|
+
import { asSchema as asSchema9 } from "@xyo-network/sdk-protocol";
|
|
139
|
+
var TemporalIndexingDivinerResultSchema = asSchema9(`${TemporalIndexingDivinerSchema}.result`, true);
|
|
140
|
+
|
|
141
|
+
// src/model/Result/Payload.ts
|
|
142
|
+
var TemporalIndexingDivinerResultZod = z5.extend(PayloadZodOfSchema(TemporalIndexingDivinerResultSchema), {
|
|
143
|
+
sources: z5.array(z5.custom()),
|
|
144
|
+
timestamp: z5.string()
|
|
145
|
+
});
|
|
146
|
+
var isTemporalIndexingDivinerResult = zodIsFactory5(TemporalIndexingDivinerResultZod);
|
|
147
|
+
var asTemporalIndexingDivinerResult = zodAsFactory5(TemporalIndexingDivinerResultZod, "asTemporalIndexingDivinerResult");
|
|
148
|
+
var toTemporalIndexingDivinerResult = zodToFactory5(TemporalIndexingDivinerResultZod, "toTemporalIndexingDivinerResult");
|
|
149
|
+
|
|
150
|
+
// src/model/ResultIndex/Payload.ts
|
|
151
|
+
import {
|
|
152
|
+
zodAsFactory as zodAsFactory6,
|
|
153
|
+
zodIsFactory as zodIsFactory6,
|
|
154
|
+
zodToFactory as zodToFactory6
|
|
155
|
+
} from "@ariestools/sdk";
|
|
156
|
+
import { PayloadZodOfSchema as PayloadZodOfSchema2 } from "@xyo-network/sdk-protocol";
|
|
157
|
+
import * as z6 from "zod/mini";
|
|
158
|
+
|
|
159
|
+
// src/model/ResultIndex/Schema.ts
|
|
160
|
+
import { asSchema as asSchema10 } from "@xyo-network/sdk-protocol";
|
|
161
|
+
var TemporalIndexingDivinerResultIndexSchema = asSchema10(`${TemporalIndexingDivinerResultSchema}.index`, true);
|
|
162
|
+
|
|
163
|
+
// src/model/ResultIndex/Payload.ts
|
|
164
|
+
var TemporalIndexingDivinerResultIndexZod = z6.extend(PayloadZodOfSchema2(TemporalIndexingDivinerResultIndexSchema), {
|
|
165
|
+
$sources: z6.array(z6.custom()),
|
|
166
|
+
timestamp: z6.number()
|
|
167
|
+
});
|
|
168
|
+
var isTemporalIndexingDivinerResultIndex = zodIsFactory6(TemporalIndexingDivinerResultIndexZod);
|
|
169
|
+
var asTemporalIndexingDivinerResultIndex = zodAsFactory6(TemporalIndexingDivinerResultIndexZod, "asTemporalIndexingDivinerResultIndex");
|
|
170
|
+
var toTemporalIndexingDivinerResultIndex = zodToFactory6(TemporalIndexingDivinerResultIndexZod, "toTemporalIndexingDivinerResultIndex");
|
|
171
|
+
|
|
172
|
+
// src/model/StateToIndexCandidateDiviner/Config.ts
|
|
173
|
+
import {
|
|
174
|
+
zodAsFactory as zodAsFactory7,
|
|
175
|
+
zodIsFactory as zodIsFactory7,
|
|
176
|
+
zodToFactory as zodToFactory7
|
|
177
|
+
} from "@ariestools/sdk";
|
|
178
|
+
import { DivinerConfigZod as DivinerConfigZod5 } from "@xyo-network/sdk/diviner-model";
|
|
179
|
+
import { asSchema as asSchema12 } from "@xyo-network/sdk-protocol";
|
|
180
|
+
import * as z7 from "zod/mini";
|
|
181
|
+
|
|
182
|
+
// src/model/StateToIndexCandidateDiviner/Schema.ts
|
|
183
|
+
import { asSchema as asSchema11 } from "@xyo-network/sdk-protocol";
|
|
184
|
+
var TemporalIndexingDivinerStateToIndexCandidateDivinerSchema = asSchema11(`${TemporalIndexingDivinerSchema}.stage.state.to.index.candidate.diviner`, true);
|
|
185
|
+
|
|
186
|
+
// src/model/StateToIndexCandidateDiviner/Config.ts
|
|
187
|
+
var TemporalIndexingDivinerStateToIndexCandidateDivinerConfigSchema = asSchema12(`${TemporalIndexingDivinerStateToIndexCandidateDivinerSchema}.config`, true);
|
|
188
|
+
var TemporalIndexingDivinerStateToIndexCandidateDivinerConfigZod = z7.extend(DivinerConfigZod5, {
|
|
189
|
+
filter: z7.optional(z7.custom()),
|
|
190
|
+
payloadDivinerLimit: z7.optional(z7.number()),
|
|
191
|
+
payloadStore: z7.optional(z7.custom()),
|
|
192
|
+
schema: z7.literal(TemporalIndexingDivinerStateToIndexCandidateDivinerConfigSchema)
|
|
193
|
+
});
|
|
194
|
+
var isTemporalIndexingDivinerStateToIndexCandidateDivinerConfig = zodIsFactory7(TemporalIndexingDivinerStateToIndexCandidateDivinerConfigZod);
|
|
195
|
+
var asTemporalIndexingDivinerStateToIndexCandidateDivinerConfig = zodAsFactory7(
|
|
196
|
+
TemporalIndexingDivinerStateToIndexCandidateDivinerConfigZod,
|
|
197
|
+
"asTemporalIndexingDivinerStateToIndexCandidateDivinerConfig"
|
|
198
|
+
);
|
|
199
|
+
var toTemporalIndexingDivinerStateToIndexCandidateDivinerConfig = zodToFactory7(
|
|
200
|
+
TemporalIndexingDivinerStateToIndexCandidateDivinerConfigZod,
|
|
201
|
+
"toTemporalIndexingDivinerStateToIndexCandidateDivinerConfig"
|
|
202
|
+
);
|
|
203
|
+
|
|
204
|
+
// src/memory/Diviner.ts
|
|
205
|
+
var TemporalIndexingDiviner = class extends IndexingDiviner {
|
|
206
|
+
static configSchemas = [...super.configSchemas, TemporalIndexingDivinerConfigSchema];
|
|
207
|
+
static defaultConfigSchema = TemporalIndexingDivinerConfigSchema;
|
|
208
|
+
async startHandler() {
|
|
209
|
+
await super.startHandler();
|
|
210
|
+
}
|
|
211
|
+
};
|
|
212
|
+
|
|
213
|
+
// src/memory/DivinerQueryToIndexQueryDiviner/Diviner.ts
|
|
214
|
+
import { jsonPathToTransformersDictionary, reducePayloads } from "@xyo-network/diviner-jsonpath-aggregate/memory";
|
|
215
|
+
import { AbstractDiviner } from "@xyo-network/sdk/diviner-abstract";
|
|
216
|
+
import { PayloadDivinerQuerySchema } from "@xyo-network/sdk/diviner-payload-model";
|
|
217
|
+
import { isPayloadOfSchemaType, PayloadBuilder } from "@xyo-network/sdk-protocol";
|
|
218
|
+
var TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner = class extends AbstractDiviner {
|
|
219
|
+
static configSchemas = [...super.configSchemas, TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema];
|
|
220
|
+
static defaultConfigSchema = TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema;
|
|
221
|
+
static labels = {
|
|
222
|
+
...super.labels,
|
|
223
|
+
"network.xyo.diviner.stage": "divinerQueryToIndexQueryDiviner"
|
|
224
|
+
};
|
|
225
|
+
_indexableSchemas;
|
|
226
|
+
_payloadTransformers;
|
|
227
|
+
/**
|
|
228
|
+
* The schema of the diviner query payloads
|
|
229
|
+
*/
|
|
230
|
+
get divinerQuerySchema() {
|
|
231
|
+
return this.config.divinerQuerySchema ?? PayloadDivinerQuerySchema;
|
|
232
|
+
}
|
|
233
|
+
/**
|
|
234
|
+
* The schema of the index query payloads
|
|
235
|
+
*/
|
|
236
|
+
get indexQuerySchema() {
|
|
237
|
+
return this.config.indexQuerySchema ?? PayloadDivinerQuerySchema;
|
|
238
|
+
}
|
|
239
|
+
/**
|
|
240
|
+
* The schema of the index payloads
|
|
241
|
+
*/
|
|
242
|
+
get indexSchema() {
|
|
243
|
+
return this.config.indexSchema ?? TemporalIndexingDivinerResultIndexSchema;
|
|
244
|
+
}
|
|
245
|
+
/**
|
|
246
|
+
* List of indexable schemas for this diviner
|
|
247
|
+
*/
|
|
248
|
+
get indexableSchemas() {
|
|
249
|
+
this._indexableSchemas ??= Object.keys(this.schemaTransforms);
|
|
250
|
+
return this._indexableSchemas;
|
|
251
|
+
}
|
|
252
|
+
/**
|
|
253
|
+
* Dictionary of schemas to payload transformers for creating indexes
|
|
254
|
+
* from the payloads within a Bound Witness
|
|
255
|
+
*/
|
|
256
|
+
get payloadTransformers() {
|
|
257
|
+
this._payloadTransformers ??= jsonPathToTransformersDictionary(this.schemaTransforms);
|
|
258
|
+
return this._payloadTransformers;
|
|
259
|
+
}
|
|
260
|
+
/**
|
|
261
|
+
* The dictionary of schemas to JSON Path transform expressions for creating indexes
|
|
262
|
+
* from the payloads within a Bound Witness
|
|
263
|
+
*/
|
|
264
|
+
get schemaTransforms() {
|
|
265
|
+
return this.config?.schemaTransforms ?? {
|
|
266
|
+
[this.divinerQuerySchema]: [
|
|
267
|
+
{
|
|
268
|
+
defaultValue: 1,
|
|
269
|
+
destinationField: "limit",
|
|
270
|
+
sourcePathExpression: "$.limit"
|
|
271
|
+
},
|
|
272
|
+
{
|
|
273
|
+
// defaultValue: 0,
|
|
274
|
+
destinationField: "cursor",
|
|
275
|
+
sourcePathExpression: "$.cursor"
|
|
276
|
+
},
|
|
277
|
+
{
|
|
278
|
+
defaultValue: "desc",
|
|
279
|
+
destinationField: "order",
|
|
280
|
+
sourcePathExpression: "$.order"
|
|
281
|
+
}
|
|
282
|
+
]
|
|
283
|
+
};
|
|
284
|
+
}
|
|
285
|
+
async divineHandler(payloads = []) {
|
|
286
|
+
const queries = payloads.filter(isPayloadOfSchemaType(this.divinerQuerySchema));
|
|
287
|
+
if (queries.length > 0) {
|
|
288
|
+
return await Promise.all(
|
|
289
|
+
queries.map(async (query) => {
|
|
290
|
+
const fields = await reducePayloads(
|
|
291
|
+
[query],
|
|
292
|
+
this.payloadTransformers,
|
|
293
|
+
this.indexQuerySchema
|
|
294
|
+
);
|
|
295
|
+
fields.schemas = [this.indexSchema];
|
|
296
|
+
delete fields.sources;
|
|
297
|
+
delete fields?.$sources;
|
|
298
|
+
return new PayloadBuilder({ schema: this.indexQuerySchema }).fields(fields).build();
|
|
299
|
+
})
|
|
300
|
+
);
|
|
301
|
+
}
|
|
302
|
+
return [];
|
|
303
|
+
}
|
|
304
|
+
};
|
|
305
|
+
|
|
306
|
+
// src/memory/IndexCandidateToIndexDiviner/Diviner.ts
|
|
307
|
+
import {
|
|
308
|
+
assertEx,
|
|
309
|
+
containsAll,
|
|
310
|
+
exists
|
|
311
|
+
} from "@ariestools/sdk";
|
|
312
|
+
import { jsonPathToTransformersDictionary as jsonPathToTransformersDictionary2 } from "@xyo-network/diviner-jsonpath-aggregate/memory";
|
|
313
|
+
import { AbstractDiviner as AbstractDiviner2 } from "@xyo-network/sdk/diviner-abstract";
|
|
314
|
+
import {
|
|
315
|
+
intraBoundwitnessSchemaCombinations,
|
|
316
|
+
isAnyPayload,
|
|
317
|
+
isBoundWitness,
|
|
318
|
+
PayloadBuilder as PayloadBuilder2
|
|
319
|
+
} from "@xyo-network/sdk-protocol";
|
|
320
|
+
var moduleName = "TemporalIndexingDivinerIndexCandidateToIndexDiviner";
|
|
321
|
+
var TemporalIndexingDivinerIndexCandidateToIndexDiviner = class extends AbstractDiviner2 {
|
|
322
|
+
static configSchemas = [...super.configSchemas, TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema];
|
|
323
|
+
static defaultConfigSchema = TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema;
|
|
324
|
+
static labels = {
|
|
325
|
+
...super.labels,
|
|
326
|
+
"network.xyo.diviner.stage": "indexCandidateToIndexDiviner"
|
|
327
|
+
};
|
|
328
|
+
_indexableSchemas;
|
|
329
|
+
_payloadTransformers;
|
|
330
|
+
/**
|
|
331
|
+
* List of indexable schemas for this diviner
|
|
332
|
+
*/
|
|
333
|
+
get indexableSchemas() {
|
|
334
|
+
this._indexableSchemas ??= Object.keys(this.schemaTransforms);
|
|
335
|
+
return this._indexableSchemas;
|
|
336
|
+
}
|
|
337
|
+
/**
|
|
338
|
+
* Dictionary of schemas to payload transformers for creating indexes
|
|
339
|
+
* from the payloads within a Bound Witness
|
|
340
|
+
*/
|
|
341
|
+
get payloadTransformers() {
|
|
342
|
+
this._payloadTransformers ??= jsonPathToTransformersDictionary2(this.schemaTransforms);
|
|
343
|
+
return this._payloadTransformers;
|
|
344
|
+
}
|
|
345
|
+
/**
|
|
346
|
+
* The dictionary of schemas to JSON Path transform expressions for creating indexes
|
|
347
|
+
* from the payloads within a Bound Witness
|
|
348
|
+
*/
|
|
349
|
+
get schemaTransforms() {
|
|
350
|
+
return assertEx(this.config?.schemaTransforms, () => `${moduleName}: Missing config.schemaTransforms section`);
|
|
351
|
+
}
|
|
352
|
+
async divineHandler(payloads = []) {
|
|
353
|
+
const indexableBoundWitnesses = payloads.filter(isBoundWitness).filter((bw) => containsAll(bw.payload_schemas, this.indexableSchemas));
|
|
354
|
+
const indexablePayloads = payloads.filter((p) => this.isIndexablePayload(p));
|
|
355
|
+
if (indexableBoundWitnesses.length === 0 || indexablePayloads.length === 0) return [];
|
|
356
|
+
const [bwDictionary, payloadDictionary] = await Promise.all([
|
|
357
|
+
PayloadBuilder2.toHashMap(indexableBoundWitnesses),
|
|
358
|
+
PayloadBuilder2.toAllHashMap(indexablePayloads)
|
|
359
|
+
]);
|
|
360
|
+
const validIndexableTuples = [];
|
|
361
|
+
for (const [bwHash, bw] of Object.entries(bwDictionary)) {
|
|
362
|
+
const combinations = intraBoundwitnessSchemaCombinations(bw, this.indexableSchemas);
|
|
363
|
+
for (const combination of combinations) {
|
|
364
|
+
const indexablePayloads2 = combination.map((hash) => payloadDictionary[hash]).filter(exists);
|
|
365
|
+
if (indexablePayloads2.length === this.indexableSchemas.length) {
|
|
366
|
+
validIndexableTuples.push([bwHash, ...combination]);
|
|
367
|
+
}
|
|
368
|
+
}
|
|
369
|
+
}
|
|
370
|
+
const indexes = validIndexableTuples.map(([bwHash, ...sourcePayloadHashes]) => {
|
|
371
|
+
const sourcePayloads = sourcePayloadHashes.map((hash) => payloadDictionary[hash]);
|
|
372
|
+
const indexFields = sourcePayloads.flatMap((payload) => {
|
|
373
|
+
const transformers = this.payloadTransformers[payload.schema];
|
|
374
|
+
return transformers ? transformers.map((transform) => transform(payload)) : [];
|
|
375
|
+
});
|
|
376
|
+
const $sources = [bwHash, ...sourcePayloadHashes];
|
|
377
|
+
return new PayloadBuilder2({ schema: TemporalIndexingDivinerResultIndexSchema }).fields(Object.assign({}, ...indexFields)).meta({ $sources }).build();
|
|
378
|
+
});
|
|
379
|
+
return indexes.flat();
|
|
380
|
+
}
|
|
381
|
+
/**
|
|
382
|
+
* Identifies if a payload is one that is indexed by this diviner
|
|
383
|
+
* @param x The candidate payload
|
|
384
|
+
* @returns True if the payload is one indexed by this diviner, false otherwise
|
|
385
|
+
*/
|
|
386
|
+
isIndexablePayload = (x) => {
|
|
387
|
+
return isAnyPayload(x) && this.indexableSchemas.includes(x?.schema);
|
|
388
|
+
};
|
|
389
|
+
/**
|
|
390
|
+
* Identifies if a schema is one that is indexed by this diviner
|
|
391
|
+
* @param schema The candidate schema
|
|
392
|
+
* @returns True if this schema is one indexed by this diviner, false otherwise
|
|
393
|
+
*/
|
|
394
|
+
isIndexableSchema = (schema) => {
|
|
395
|
+
return typeof schema === "string" ? this.indexableSchemas.includes(schema) : false;
|
|
396
|
+
};
|
|
397
|
+
};
|
|
398
|
+
|
|
399
|
+
// src/memory/IndexQueryResponseToDivinerQueryResponseDiviner/Diviner.ts
|
|
400
|
+
import { AbstractDiviner as AbstractDiviner3 } from "@xyo-network/sdk/diviner-abstract";
|
|
401
|
+
import { isPayloadDivinerQueryPayload } from "@xyo-network/sdk/diviner-payload-model";
|
|
402
|
+
var TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner = class extends AbstractDiviner3 {
|
|
403
|
+
static configSchemas = [
|
|
404
|
+
...super.configSchemas,
|
|
405
|
+
TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigSchema
|
|
406
|
+
];
|
|
407
|
+
static defaultConfigSchema = TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigSchema;
|
|
408
|
+
static labels = {
|
|
409
|
+
...super.labels,
|
|
410
|
+
"network.xyo.diviner.stage": "indexQueryResponseToDivinerQueryResponseDiviner"
|
|
411
|
+
};
|
|
412
|
+
async divineHandler(payloads = []) {
|
|
413
|
+
const responses = payloads.filter((p) => !isPayloadDivinerQueryPayload(p));
|
|
414
|
+
return responses;
|
|
415
|
+
}
|
|
416
|
+
};
|
|
417
|
+
|
|
418
|
+
// src/memory/StateToIndexCandidateDiviner/Diviner.ts
|
|
419
|
+
import { assertEx as assertEx2, exists as exists2 } from "@ariestools/sdk";
|
|
420
|
+
import { ArchivistWrapper } from "@xyo-network/sdk/archivist-wrapper";
|
|
421
|
+
import { AbstractDiviner as AbstractDiviner4 } from "@xyo-network/sdk/diviner-abstract";
|
|
422
|
+
import { DivinerWrapper } from "@xyo-network/sdk/diviner-wrapper";
|
|
423
|
+
import { isModuleState, ModuleStateSchema } from "@xyo-network/sdk/module-model";
|
|
424
|
+
import {
|
|
425
|
+
intraBoundwitnessSchemaCombinations as intraBoundwitnessSchemaCombinations2,
|
|
426
|
+
isBoundWitness as isBoundWitness2,
|
|
427
|
+
payloadSchemasContainsAll,
|
|
428
|
+
SequenceConstants
|
|
429
|
+
} from "@xyo-network/sdk-protocol";
|
|
430
|
+
import { TimestampSchema } from "@xyo-network/witness-timestamp";
|
|
431
|
+
var order = "asc";
|
|
432
|
+
var moduleName2 = "TemporalIndexingDivinerStateToIndexCandidateDiviner";
|
|
433
|
+
var TemporalIndexingDivinerStateToIndexCandidateDiviner = class extends AbstractDiviner4 {
|
|
434
|
+
static configSchemas = [...super.configSchemas, TemporalIndexingDivinerStateToIndexCandidateDivinerConfigSchema];
|
|
435
|
+
static defaultConfigSchema = TemporalIndexingDivinerStateToIndexCandidateDivinerConfigSchema;
|
|
436
|
+
static labels = {
|
|
437
|
+
...super.labels,
|
|
438
|
+
"network.xyo.diviner.stage": "stateToIndexCandidateDiviner"
|
|
439
|
+
};
|
|
440
|
+
get payloadDivinerLimit() {
|
|
441
|
+
return this.config.payloadDivinerLimit ?? 1e3;
|
|
442
|
+
}
|
|
443
|
+
/**
|
|
444
|
+
* The required payload_schemas within BoundWitnesses to identify index candidates
|
|
445
|
+
*/
|
|
446
|
+
get payload_schemas() {
|
|
447
|
+
const schemas = this.config.filter?.payload_schemas;
|
|
448
|
+
return [TimestampSchema, ...schemas ?? []];
|
|
449
|
+
}
|
|
450
|
+
async divineHandler(payloads = []) {
|
|
451
|
+
const lastState = payloads.find(isModuleState) ?? { schema: ModuleStateSchema, state: { cursor: SequenceConstants.minLocalSequence } };
|
|
452
|
+
const cursor = lastState?.state?.cursor;
|
|
453
|
+
const sourceArchivist = await this.getArchivistForStore();
|
|
454
|
+
if (!sourceArchivist) return [lastState];
|
|
455
|
+
const nextOffset = { limit: this.payloadDivinerLimit, order };
|
|
456
|
+
if (cursor !== SequenceConstants.minLocalSequence) nextOffset.cursor = cursor;
|
|
457
|
+
const next = await sourceArchivist.next(nextOffset);
|
|
458
|
+
if (next.length === 0) return [lastState];
|
|
459
|
+
const batch = next.filter((x) => isBoundWitness2(x)).filter(exists2).filter((bw) => payloadSchemasContainsAll(bw, this.payload_schemas));
|
|
460
|
+
const indexCandidates = (await Promise.all(batch.map((bw) => this.getPayloadsInBoundWitness(bw, sourceArchivist)))).filter(exists2).flat();
|
|
461
|
+
const nextCursor = assertEx2(next.at(-1)?._sequence, () => `${moduleName2}: Expected next to have a sequence`);
|
|
462
|
+
const nextState = { schema: ModuleStateSchema, state: { ...lastState.state, cursor: nextCursor } };
|
|
463
|
+
return [nextState, ...indexCandidates];
|
|
464
|
+
}
|
|
465
|
+
/**
|
|
466
|
+
* Retrieves the archivist for the payloadStore
|
|
467
|
+
* @returns The archivist for the payloadStore or undefined if not resolvable
|
|
468
|
+
*/
|
|
469
|
+
async getArchivistForStore() {
|
|
470
|
+
const name = assertEx2(
|
|
471
|
+
this.config?.payloadStore?.archivist,
|
|
472
|
+
() => `${moduleName2}: Config for payloadStore.archivist not specified`
|
|
473
|
+
);
|
|
474
|
+
const mod = await this.resolve(name);
|
|
475
|
+
if (!mod) return void 0;
|
|
476
|
+
return ArchivistWrapper.wrap(mod, this.account);
|
|
477
|
+
}
|
|
478
|
+
/**
|
|
479
|
+
* Retrieves the BoundWitness Diviner for the payloadStore
|
|
480
|
+
* @returns The BoundWitness Diviner for the payloadStore or undefined if not resolvable
|
|
481
|
+
*/
|
|
482
|
+
async getBoundWitnessDivinerForStore() {
|
|
483
|
+
const name = assertEx2(
|
|
484
|
+
this.config?.payloadStore?.boundWitnessDiviner,
|
|
485
|
+
() => `${moduleName2}: Config for payloadStore.boundWitnessDiviner not specified`
|
|
486
|
+
);
|
|
487
|
+
const mod = await this.resolve(name);
|
|
488
|
+
if (!mod) return;
|
|
489
|
+
return DivinerWrapper.wrap(mod, this.account);
|
|
490
|
+
}
|
|
491
|
+
async getPayloadsInBoundWitness(bw, archivist) {
|
|
492
|
+
const combinations = intraBoundwitnessSchemaCombinations2(bw, this.payload_schemas).flat();
|
|
493
|
+
if (combinations.length === 0) return void 0;
|
|
494
|
+
const hashes = new Set(combinations);
|
|
495
|
+
const indexCandidates = await archivist.get([...hashes]);
|
|
496
|
+
return [bw, ...indexCandidates];
|
|
497
|
+
}
|
|
498
|
+
};
|
|
499
|
+
export {
|
|
500
|
+
TemporalIndexingDiviner,
|
|
501
|
+
TemporalIndexingDivinerConfigSchema,
|
|
502
|
+
TemporalIndexingDivinerConfigZod,
|
|
503
|
+
TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner,
|
|
504
|
+
TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigSchema,
|
|
505
|
+
TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfigZod,
|
|
506
|
+
TemporalIndexingDivinerDivinerQueryToIndexQueryDivinerSchema,
|
|
507
|
+
TemporalIndexingDivinerIndexCandidateToIndexDiviner,
|
|
508
|
+
TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigSchema,
|
|
509
|
+
TemporalIndexingDivinerIndexCandidateToIndexDivinerConfigZod,
|
|
510
|
+
TemporalIndexingDivinerIndexCandidateToIndexDivinerSchema,
|
|
511
|
+
TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner,
|
|
512
|
+
TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigSchema,
|
|
513
|
+
TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfigZod,
|
|
514
|
+
TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerSchema,
|
|
515
|
+
TemporalIndexingDivinerResultIndexSchema,
|
|
516
|
+
TemporalIndexingDivinerResultIndexZod,
|
|
517
|
+
TemporalIndexingDivinerResultSchema,
|
|
518
|
+
TemporalIndexingDivinerResultZod,
|
|
519
|
+
TemporalIndexingDivinerSchema,
|
|
520
|
+
TemporalIndexingDivinerStateToIndexCandidateDiviner,
|
|
521
|
+
TemporalIndexingDivinerStateToIndexCandidateDivinerConfigSchema,
|
|
522
|
+
TemporalIndexingDivinerStateToIndexCandidateDivinerConfigZod,
|
|
523
|
+
TemporalIndexingDivinerStateToIndexCandidateDivinerSchema,
|
|
524
|
+
asTemporalIndexingDivinerConfig,
|
|
525
|
+
asTemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig,
|
|
526
|
+
asTemporalIndexingDivinerIndexCandidateToIndexDivinerConfig,
|
|
527
|
+
asTemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfig,
|
|
528
|
+
asTemporalIndexingDivinerResult,
|
|
529
|
+
asTemporalIndexingDivinerResultIndex,
|
|
530
|
+
asTemporalIndexingDivinerStateToIndexCandidateDivinerConfig,
|
|
531
|
+
isTemporalIndexingDivinerConfig,
|
|
532
|
+
isTemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig,
|
|
533
|
+
isTemporalIndexingDivinerIndexCandidateToIndexDivinerConfig,
|
|
534
|
+
isTemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfig,
|
|
535
|
+
isTemporalIndexingDivinerResult,
|
|
536
|
+
isTemporalIndexingDivinerResultIndex,
|
|
537
|
+
isTemporalIndexingDivinerStateToIndexCandidateDivinerConfig,
|
|
538
|
+
toTemporalIndexingDivinerConfig,
|
|
539
|
+
toTemporalIndexingDivinerDivinerQueryToIndexQueryDivinerConfig,
|
|
540
|
+
toTemporalIndexingDivinerIndexCandidateToIndexDivinerConfig,
|
|
541
|
+
toTemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDivinerConfig,
|
|
542
|
+
toTemporalIndexingDivinerResult,
|
|
543
|
+
toTemporalIndexingDivinerResultIndex,
|
|
544
|
+
toTemporalIndexingDivinerStateToIndexCandidateDivinerConfig
|
|
545
|
+
};
|
|
4
546
|
//# sourceMappingURL=index.mjs.map
|