@domino-sdk/relay 1.0.0-next.5 → 1.0.0-next.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +13 -1
- package/build.mjs +18 -1
- package/dist/authoring.d.ts +322 -14
- package/dist/authoring.js +187 -25
- package/dist/avatar.d.ts +29 -0
- package/dist/avatar.js +21 -0
- package/dist/browser.d.ts +19 -3
- package/dist/browser.js +6 -6
- package/dist/catalog-C09gnPYT.d.ts +3948 -0
- package/dist/chunk-7HSTFBMO.js +24 -0
- package/dist/{chunk-VH4OQ5VX.js → chunk-ADSP377G.js} +1 -1
- package/dist/{chunk-FDWRBMB3.js → chunk-AWLLGCKU.js} +2 -2
- package/dist/chunk-DJZB5RY5.js +901 -0
- package/dist/chunk-SKETUPST.js +171 -0
- package/dist/chunk-UFXBQ6FN.js +257 -0
- package/dist/{chunk-NKGJEYZM.js → chunk-UW6R2QGT.js} +610 -719
- package/dist/chunk-V7UKZLHA.js +35 -0
- package/dist/{chunk-4KNTMNXA.js → chunk-X6FJIPXR.js} +166 -724
- package/dist/client-BufGakEt.d.ts +4577 -0
- package/dist/collection-BGneJ6Bk.d.ts +114 -0
- package/dist/images-e6FW9QSx.d.ts +234 -0
- package/dist/index.d.ts +11 -13115
- package/dist/index.js +11 -693
- package/dist/integrations-C3Sp558f.d.ts +1297 -0
- package/dist/internal.d.ts +109 -0
- package/dist/internal.js +104 -0
- package/dist/point-ledgers-iS00Z_v0.d.ts +37 -0
- package/dist/portal-proxy.js +5 -6
- package/dist/profiles-BtOXMGcC.d.ts +297 -0
- package/dist/react/index.d.ts +51 -34
- package/dist/react/index.js +7 -13
- package/dist/schema-DCapSPHz.d.ts +3396 -0
- package/dist/schema.d.ts +3194 -2366
- package/dist/schema.js +539 -3
- package/dist/streaks-CwGReWGt.d.ts +73 -0
- package/dist/submission-input-Bter6XiI.d.ts +2672 -0
- package/dist/units-CwgsPB_r.d.ts +9 -0
- package/dist/wallet-Bu6sqJvQ.d.ts +231 -0
- package/package.json +17 -4
- package/dist/chunk-B76BAJ25.js +0 -624
- package/dist/chunk-ONDBQSMU.js +0 -373
- package/dist/submission-input-CZDukyb3.d.ts +0 -4998
|
@@ -1,26 +1,48 @@
|
|
|
1
|
-
// src/
|
|
2
|
-
import { z
|
|
1
|
+
// src/accounts.ts
|
|
2
|
+
import { z } from "zod";
|
|
3
|
+
var authProviderSchema = z.enum(["google", "apple", "x", "discord"]);
|
|
4
|
+
var accountConnectionSchema = z.object({
|
|
5
|
+
provider: authProviderSchema,
|
|
6
|
+
configured: z.boolean(),
|
|
7
|
+
status: z.enum(["disconnected", "connected", "reconnect"]),
|
|
8
|
+
subject: z.string().nullable(),
|
|
9
|
+
revision: z.number().int().nonnegative()
|
|
10
|
+
});
|
|
11
|
+
var discordMemberInputSchema = z.object({}).strict();
|
|
12
|
+
var discordMessageInputSchema = z.object({
|
|
13
|
+
channelId: z.string().regex(/^[0-9]{1,20}$/),
|
|
14
|
+
messageId: z.string().regex(/^[0-9]{1,20}$/)
|
|
15
|
+
}).strict();
|
|
16
|
+
var discordMemberSchema = z.object({
|
|
17
|
+
userId: z.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
|
|
18
|
+
nickname: z.string().nullable().default(null),
|
|
19
|
+
displayName: z.string().nullable().default(null),
|
|
20
|
+
boostingSince: z.string().datetime({ offset: true }).nullable().default(null),
|
|
21
|
+
roles: z.array(z.string().regex(/^[0-9]{1,20}$/)),
|
|
22
|
+
joinedAt: z.string().datetime({ offset: true }).nullable(),
|
|
23
|
+
pending: z.boolean()
|
|
24
|
+
});
|
|
3
25
|
|
|
4
26
|
// src/identifier.ts
|
|
5
|
-
import { z } from "zod";
|
|
6
|
-
var identifier =
|
|
27
|
+
import { z as z2 } from "zod";
|
|
28
|
+
var identifier = z2.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
|
|
7
29
|
|
|
8
30
|
// src/trackers.ts
|
|
9
|
-
import { z as
|
|
10
|
-
var timestamp =
|
|
11
|
-
var count =
|
|
12
|
-
var externalId =
|
|
31
|
+
import { z as z3 } from "zod";
|
|
32
|
+
var timestamp = z3.number().int().safe().nonnegative().max(864e13);
|
|
33
|
+
var count = z3.number().int().safe().nonnegative();
|
|
34
|
+
var externalId = z3.string().min(1).max(256);
|
|
13
35
|
var metric = count.nullable().default(null);
|
|
14
|
-
var xTweetSchema =
|
|
36
|
+
var xTweetSchema = z3.looseObject({
|
|
15
37
|
id: externalId,
|
|
16
38
|
userId: externalId,
|
|
17
|
-
content:
|
|
18
|
-
createdAt:
|
|
19
|
-
author:
|
|
39
|
+
content: z3.string(),
|
|
40
|
+
createdAt: z3.iso.datetime({ offset: true }),
|
|
41
|
+
author: z3.looseObject({
|
|
20
42
|
id: externalId,
|
|
21
|
-
username:
|
|
22
|
-
name:
|
|
23
|
-
verified:
|
|
43
|
+
username: z3.string(),
|
|
44
|
+
name: z3.string(),
|
|
45
|
+
verified: z3.boolean().nullable().default(null)
|
|
24
46
|
}),
|
|
25
47
|
likeCount: metric,
|
|
26
48
|
replyCount: metric,
|
|
@@ -28,90 +50,90 @@ var xTweetSchema = z2.looseObject({
|
|
|
28
50
|
quoteCount: metric,
|
|
29
51
|
viewCount: metric,
|
|
30
52
|
bookmarkCount: metric,
|
|
31
|
-
isReply:
|
|
32
|
-
isRetweet:
|
|
33
|
-
isQuoteTweet:
|
|
53
|
+
isReply: z3.boolean(),
|
|
54
|
+
isRetweet: z3.boolean(),
|
|
55
|
+
isQuoteTweet: z3.boolean()
|
|
34
56
|
});
|
|
35
|
-
var xContentBodySchema =
|
|
36
|
-
version:
|
|
37
|
-
id:
|
|
38
|
-
authorId:
|
|
57
|
+
var xContentBodySchema = z3.strictObject({
|
|
58
|
+
version: z3.literal(1),
|
|
59
|
+
id: z3.string().min(1),
|
|
60
|
+
authorId: z3.string().min(1),
|
|
39
61
|
publishedAt: timestamp,
|
|
40
|
-
text:
|
|
41
|
-
isReply:
|
|
42
|
-
isRetweet:
|
|
43
|
-
isQuoteTweet:
|
|
44
|
-
media:
|
|
45
|
-
mentionedAuthorIds:
|
|
46
|
-
videoLengthSeconds:
|
|
47
|
-
references:
|
|
48
|
-
replyId:
|
|
49
|
-
replyAuthorId:
|
|
50
|
-
quoteId:
|
|
51
|
-
quoteAuthorId:
|
|
52
|
-
repostId:
|
|
53
|
-
repostAuthorId:
|
|
62
|
+
text: z3.string(),
|
|
63
|
+
isReply: z3.boolean(),
|
|
64
|
+
isRetweet: z3.boolean(),
|
|
65
|
+
isQuoteTweet: z3.boolean(),
|
|
66
|
+
media: z3.array(z3.strictObject({ type: z3.string(), url: z3.string() })).nullable(),
|
|
67
|
+
mentionedAuthorIds: z3.array(z3.string().min(1)).nullable(),
|
|
68
|
+
videoLengthSeconds: z3.number().nonnegative().nullable(),
|
|
69
|
+
references: z3.strictObject({
|
|
70
|
+
replyId: z3.string().nullable(),
|
|
71
|
+
replyAuthorId: z3.string().nullable(),
|
|
72
|
+
quoteId: z3.string().nullable(),
|
|
73
|
+
quoteAuthorId: z3.string().nullable(),
|
|
74
|
+
repostId: z3.string().nullable(),
|
|
75
|
+
repostAuthorId: z3.string().nullable()
|
|
54
76
|
})
|
|
55
77
|
});
|
|
56
|
-
var trackerContentQuerySchema =
|
|
78
|
+
var trackerContentQuerySchema = z3.strictObject({
|
|
57
79
|
id: externalId,
|
|
58
|
-
observation:
|
|
80
|
+
observation: z3.string().regex(/^observation_[a-f0-9]{64}$/)
|
|
59
81
|
});
|
|
60
82
|
var trackerContentReadSchema = trackerContentQuerySchema.extend({
|
|
61
83
|
member: identifier
|
|
62
84
|
});
|
|
63
85
|
var attributionContext = { member: identifier, capturedAt: timestamp };
|
|
64
|
-
var trackerEvidenceSchema =
|
|
86
|
+
var trackerEvidenceSchema = z3.strictObject({
|
|
65
87
|
contentRevision: identifier,
|
|
66
88
|
observation: identifier
|
|
67
89
|
});
|
|
68
|
-
var trackerContentSchema =
|
|
90
|
+
var trackerContentSchema = z3.strictObject({
|
|
69
91
|
tracker: identifier,
|
|
70
|
-
source:
|
|
92
|
+
source: z3.literal("x"),
|
|
71
93
|
evidence: trackerEvidenceSchema,
|
|
72
94
|
content: xContentBodySchema,
|
|
73
95
|
observedAt: timestamp,
|
|
74
|
-
removed:
|
|
75
|
-
attribution:
|
|
76
|
-
|
|
96
|
+
removed: z3.boolean(),
|
|
97
|
+
attribution: z3.discriminatedUnion("kind", [
|
|
98
|
+
z3.strictObject({
|
|
77
99
|
...attributionContext,
|
|
78
|
-
kind:
|
|
79
|
-
account:
|
|
80
|
-
provider:
|
|
81
|
-
issuer:
|
|
100
|
+
kind: z3.literal("linked"),
|
|
101
|
+
account: z3.strictObject({
|
|
102
|
+
provider: z3.literal("x"),
|
|
103
|
+
issuer: z3.string().min(1),
|
|
82
104
|
subject: externalId,
|
|
83
105
|
revision: count,
|
|
84
106
|
linkedAt: timestamp.nullable()
|
|
85
107
|
})
|
|
86
108
|
}),
|
|
87
|
-
|
|
88
|
-
|
|
109
|
+
z3.strictObject({ ...attributionContext, kind: z3.literal("unlinked") }),
|
|
110
|
+
z3.strictObject({
|
|
89
111
|
...attributionContext,
|
|
90
|
-
kind:
|
|
112
|
+
kind: z3.literal("different-author")
|
|
91
113
|
})
|
|
92
114
|
])
|
|
93
115
|
});
|
|
94
|
-
var identityKindSchema =
|
|
95
|
-
var accountRoleSchema =
|
|
116
|
+
var identityKindSchema = z3.enum(["wallet", "x", "discord", "member"]);
|
|
117
|
+
var accountRoleSchema = z3.string().regex(
|
|
96
118
|
/^[a-zA-Z][a-zA-Z0-9_]{0,39}$/,
|
|
97
119
|
"Name roles like author or recipient: a letter, then letters, digits or underscores"
|
|
98
120
|
);
|
|
99
121
|
var xAccountRoles = ["author", "inReplyTo"];
|
|
100
122
|
var distinct = (values) => new Set(values).size === values.length;
|
|
101
|
-
var xSearchSourceSchema =
|
|
102
|
-
kind:
|
|
103
|
-
query:
|
|
123
|
+
var xSearchSourceSchema = z3.object({
|
|
124
|
+
kind: z3.literal("x-search"),
|
|
125
|
+
query: z3.string().trim().min(1).max(2e3)
|
|
104
126
|
}).strict();
|
|
105
|
-
var customSourceSchema =
|
|
106
|
-
kind:
|
|
127
|
+
var customSourceSchema = z3.object({
|
|
128
|
+
kind: z3.literal("custom"),
|
|
107
129
|
namespace: identifier,
|
|
108
130
|
/**
|
|
109
131
|
* The identity kinds a record's author and named accounts can be, attributed to members
|
|
110
132
|
* through verified links. Omitted when authors are opaque IDs, which no quest can pay.
|
|
111
133
|
*/
|
|
112
|
-
identities:
|
|
134
|
+
identities: z3.array(identityKindSchema).min(1).max(4).refine(distinct, "List each identity kind once").optional(),
|
|
113
135
|
/** Roles of the named accounts records can carry besides their author, such as `recipient`. */
|
|
114
|
-
accounts:
|
|
136
|
+
accounts: z3.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
|
|
115
137
|
(roles) => !roles.includes("author"),
|
|
116
138
|
"author is every record's own role; name other accounts"
|
|
117
139
|
).optional(),
|
|
@@ -121,7 +143,7 @@ var customSourceSchema = z2.object({
|
|
|
121
143
|
*
|
|
122
144
|
* @deprecated Use `identities: ["wallet"]`.
|
|
123
145
|
*/
|
|
124
|
-
authors:
|
|
146
|
+
authors: z3.literal("wallet").optional()
|
|
125
147
|
}).strict().refine(
|
|
126
148
|
(source) => !(source.authors && source.identities),
|
|
127
149
|
"Use identities, not authors"
|
|
@@ -129,7 +151,7 @@ var customSourceSchema = z2.object({
|
|
|
129
151
|
(source) => !source.accounts || source.identities,
|
|
130
152
|
"Named accounts need identities"
|
|
131
153
|
);
|
|
132
|
-
var trackerSourceSchema =
|
|
154
|
+
var trackerSourceSchema = z3.discriminatedUnion("kind", [
|
|
133
155
|
xSearchSourceSchema,
|
|
134
156
|
customSourceSchema
|
|
135
157
|
]);
|
|
@@ -139,94 +161,83 @@ function sourceIdentities(source) {
|
|
|
139
161
|
}
|
|
140
162
|
return source.identities ?? (source.authors === "wallet" ? ["wallet"] : void 0);
|
|
141
163
|
}
|
|
142
|
-
var
|
|
143
|
-
search: (input) => xSearchSourceSchema.parse({ kind: "x-search", ...input })
|
|
144
|
-
};
|
|
145
|
-
var customSource = (namespace, options = {}) => customSourceSchema.parse({
|
|
146
|
-
kind: "custom",
|
|
147
|
-
namespace,
|
|
148
|
-
...options
|
|
149
|
-
});
|
|
150
|
-
var windowSchema = z2.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
|
|
164
|
+
var windowSchema = z3.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
|
|
151
165
|
(w) => w.end === void 0 || w.end > w.start,
|
|
152
166
|
"End must follow start"
|
|
153
167
|
);
|
|
154
|
-
var trackerDefinitionSchema =
|
|
168
|
+
var trackerDefinitionSchema = z3.object({
|
|
155
169
|
key: identifier,
|
|
156
|
-
title:
|
|
170
|
+
title: z3.string().trim().min(1).max(120),
|
|
157
171
|
source: trackerSourceSchema,
|
|
158
172
|
window: windowSchema,
|
|
159
|
-
refreshSeconds:
|
|
160
|
-
maxPages:
|
|
173
|
+
refreshSeconds: z3.number().int().min(300).max(86400).default(21600),
|
|
174
|
+
maxPages: z3.number().int().min(1).max(1e3).default(60)
|
|
161
175
|
}).strict();
|
|
162
|
-
var trackerArtifactSchema =
|
|
176
|
+
var trackerArtifactSchema = z3.union([
|
|
163
177
|
trackerDefinitionSchema,
|
|
164
|
-
|
|
178
|
+
z3.object({ code: z3.string().min(1).max(2e6) }).strict()
|
|
165
179
|
]);
|
|
166
|
-
|
|
167
|
-
return trackerDefinitionSchema.parse(input);
|
|
168
|
-
}
|
|
169
|
-
var publishedTrackerSchema = z2.object({
|
|
180
|
+
var publishedTrackerSchema = z3.object({
|
|
170
181
|
id: identifier,
|
|
171
182
|
version: identifier,
|
|
172
183
|
definition: trackerDefinitionSchema,
|
|
173
184
|
publishedAt: timestamp,
|
|
174
|
-
actor:
|
|
185
|
+
actor: z3.string().nullable()
|
|
175
186
|
});
|
|
176
|
-
var trackerStatusSchema =
|
|
187
|
+
var trackerStatusSchema = z3.object({
|
|
177
188
|
published: publishedTrackerSchema,
|
|
178
|
-
paused:
|
|
179
|
-
state:
|
|
189
|
+
paused: z3.boolean(),
|
|
190
|
+
state: z3.enum(["idle", "syncing", "error", "complete"]),
|
|
180
191
|
lastStartedAt: timestamp.nullable(),
|
|
181
192
|
lastCompletedAt: timestamp.nullable(),
|
|
182
193
|
nextSyncAt: timestamp.nullable(),
|
|
183
|
-
coverage:
|
|
184
|
-
error:
|
|
194
|
+
coverage: z3.enum(["unknown", "partial", "complete"]),
|
|
195
|
+
error: z3.string().nullable(),
|
|
185
196
|
records: count
|
|
186
197
|
});
|
|
187
|
-
var trackerControlSchema =
|
|
198
|
+
var trackerControlSchema = z3.object({
|
|
188
199
|
actionId: identifier,
|
|
189
|
-
action:
|
|
200
|
+
action: z3.enum(["pause", "resume", "refresh"])
|
|
190
201
|
}).strict();
|
|
191
|
-
var trackerAccountSchema =
|
|
202
|
+
var trackerAccountSchema = z3.strictObject({
|
|
192
203
|
kind: identityKindSchema.optional(),
|
|
193
204
|
id: externalId
|
|
194
205
|
});
|
|
195
|
-
var trackerRecordInputSchema =
|
|
206
|
+
var trackerRecordInputSchema = z3.object({
|
|
196
207
|
id: externalId,
|
|
197
208
|
occurredAt: timestamp,
|
|
198
209
|
observedAt: timestamp,
|
|
199
|
-
author:
|
|
210
|
+
author: z3.object({
|
|
200
211
|
id: externalId,
|
|
201
|
-
verified:
|
|
212
|
+
verified: z3.boolean().nullable().default(null),
|
|
202
213
|
/** The author's identity kind; needed when the source names more than one. */
|
|
203
214
|
kind: identityKindSchema.optional()
|
|
204
215
|
}).strict().nullable().default(null),
|
|
205
216
|
/** Named accounts besides the author, by the roles the custom source declares. */
|
|
206
|
-
accounts:
|
|
217
|
+
accounts: z3.record(accountRoleSchema, trackerAccountSchema).refine(
|
|
207
218
|
(accounts) => Object.keys(accounts).length <= 10,
|
|
208
219
|
"At most 10 accounts"
|
|
209
220
|
).optional(),
|
|
210
|
-
data:
|
|
211
|
-
removed:
|
|
221
|
+
data: z3.record(z3.string(), z3.json()),
|
|
222
|
+
removed: z3.boolean().default(false)
|
|
212
223
|
}).strict().refine(
|
|
213
224
|
(v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
|
|
214
225
|
"Record exceeds 128 KB"
|
|
215
226
|
);
|
|
216
227
|
var trackerRecordSchema = trackerRecordInputSchema.safeExtend({
|
|
217
|
-
source:
|
|
228
|
+
source: z3.string(),
|
|
218
229
|
firstSeenAt: timestamp,
|
|
219
230
|
/** Present only when includeEvidence is true; custom sources have no X evidence. */
|
|
220
231
|
evidence: trackerEvidenceSchema.nullable().optional()
|
|
221
232
|
});
|
|
222
|
-
var trackerIngestSchema =
|
|
233
|
+
var trackerIngestSchema = z3.object({
|
|
223
234
|
actionId: identifier,
|
|
224
|
-
records:
|
|
235
|
+
records: z3.array(trackerRecordInputSchema).min(1).max(100)
|
|
225
236
|
}).strict();
|
|
226
|
-
var trackerIngestResultSchema =
|
|
237
|
+
var trackerIngestResultSchema = z3.object({
|
|
227
238
|
stored: count,
|
|
228
239
|
/** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
|
|
229
|
-
admissions:
|
|
240
|
+
admissions: z3.object({
|
|
230
241
|
admitted: count,
|
|
231
242
|
skipped: count,
|
|
232
243
|
/**
|
|
@@ -247,11 +258,11 @@ var trackerOutcomeFields = {
|
|
|
247
258
|
/** The release admitted, or the one active when the observation was skipped. */
|
|
248
259
|
release: identifier,
|
|
249
260
|
/** The account attribution resolved or failed to resolve, such as a CAIP-10 wallet ID. */
|
|
250
|
-
account:
|
|
261
|
+
account: z3.string().nullable(),
|
|
251
262
|
createdAt: timestamp,
|
|
252
263
|
updatedAt: timestamp,
|
|
253
264
|
/** Null for automatic decisions; the staff actor after a retry. */
|
|
254
|
-
actor:
|
|
265
|
+
actor: z3.string().nullable()
|
|
255
266
|
};
|
|
256
267
|
var trackerSkipCodes = [
|
|
257
268
|
/** The quest is paused or no longer active. */
|
|
@@ -279,84 +290,84 @@ var trackerSkipCodes = [
|
|
|
279
290
|
/** The attributed member has not completed the quest's prerequisites. */
|
|
280
291
|
"prerequisites-incomplete"
|
|
281
292
|
];
|
|
282
|
-
var trackerOutcomeSchema =
|
|
283
|
-
|
|
293
|
+
var trackerOutcomeSchema = z3.discriminatedUnion("state", [
|
|
294
|
+
z3.strictObject({
|
|
284
295
|
...trackerOutcomeFields,
|
|
285
|
-
state:
|
|
286
|
-
code:
|
|
287
|
-
reason:
|
|
296
|
+
state: z3.literal("admitted"),
|
|
297
|
+
code: z3.null(),
|
|
298
|
+
reason: z3.null(),
|
|
288
299
|
/** The attributed member. */
|
|
289
300
|
member: identifier,
|
|
290
301
|
/** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
|
|
291
302
|
attempt: identifier
|
|
292
303
|
}),
|
|
293
|
-
|
|
304
|
+
z3.strictObject({
|
|
294
305
|
...trackerOutcomeFields,
|
|
295
|
-
state:
|
|
306
|
+
state: z3.literal("skipped"),
|
|
296
307
|
/** Why the observation was skipped, as one of `trackerSkipCodes`. */
|
|
297
|
-
code:
|
|
308
|
+
code: z3.string().min(1),
|
|
298
309
|
/** Why the observation was skipped, for people. */
|
|
299
|
-
reason:
|
|
310
|
+
reason: z3.string(),
|
|
300
311
|
/** The attributed member, when attribution got that far. */
|
|
301
312
|
member: identifier.nullable(),
|
|
302
313
|
attempt: identifier.nullable()
|
|
303
314
|
})
|
|
304
315
|
]);
|
|
305
|
-
var trackerOutcomeQuerySchema =
|
|
316
|
+
var trackerOutcomeQuerySchema = z3.strictObject({
|
|
306
317
|
/** Quest key or ID. */
|
|
307
318
|
quest: identifier.optional(),
|
|
308
319
|
record: externalId.optional(),
|
|
309
320
|
member: identifier.optional(),
|
|
310
|
-
state:
|
|
321
|
+
state: z3.enum(["admitted", "skipped"]).optional(),
|
|
311
322
|
/** Only skips with this code, such as `unlinked-account`. */
|
|
312
|
-
code:
|
|
313
|
-
limit:
|
|
323
|
+
code: z3.string().min(1).max(100).optional(),
|
|
324
|
+
limit: z3.coerce.number().int().min(1).max(100).default(25),
|
|
314
325
|
/** Opaque cursor from `next`: older outcomes. */
|
|
315
|
-
before:
|
|
326
|
+
before: z3.string().max(512).optional()
|
|
316
327
|
});
|
|
317
|
-
var trackerOutcomePageSchema =
|
|
328
|
+
var trackerOutcomePageSchema = z3.strictObject({
|
|
318
329
|
/** Newest first. */
|
|
319
|
-
items:
|
|
320
|
-
next:
|
|
330
|
+
items: z3.array(trackerOutcomeSchema).max(100),
|
|
331
|
+
next: z3.string().nullable()
|
|
321
332
|
});
|
|
322
|
-
var trackerOutcomeRetrySchema =
|
|
333
|
+
var trackerOutcomeRetrySchema = z3.strictObject({
|
|
323
334
|
actionId: identifier,
|
|
324
335
|
/** Quest key or ID. */
|
|
325
336
|
quest: identifier,
|
|
326
337
|
record: externalId,
|
|
327
338
|
observedAt: timestamp
|
|
328
339
|
});
|
|
329
|
-
var booleanQuery =
|
|
330
|
-
|
|
331
|
-
|
|
340
|
+
var booleanQuery = z3.union([
|
|
341
|
+
z3.boolean(),
|
|
342
|
+
z3.enum(["true", "false"]).transform((v) => v === "true")
|
|
332
343
|
]);
|
|
333
|
-
var trackerQuerySchema =
|
|
344
|
+
var trackerQuerySchema = z3.object({
|
|
334
345
|
author: externalId.optional(),
|
|
335
346
|
member: identifier.optional(),
|
|
336
347
|
verified: booleanQuery.optional(),
|
|
337
|
-
since:
|
|
338
|
-
until:
|
|
348
|
+
since: z3.coerce.number().int().safe().nonnegative().optional(),
|
|
349
|
+
until: z3.coerce.number().int().safe().nonnegative().optional(),
|
|
339
350
|
removed: booleanQuery.default(false),
|
|
340
|
-
minLikes:
|
|
341
|
-
minViews:
|
|
342
|
-
limit:
|
|
343
|
-
cursor:
|
|
351
|
+
minLikes: z3.coerce.number().int().safe().nonnegative().optional(),
|
|
352
|
+
minViews: z3.coerce.number().int().safe().nonnegative().optional(),
|
|
353
|
+
limit: z3.coerce.number().int().min(1).max(100).default(25),
|
|
354
|
+
cursor: z3.string().max(2048).optional(),
|
|
344
355
|
includeEvidence: booleanQuery.optional()
|
|
345
356
|
}).strict().refine(
|
|
346
357
|
(q) => q.since === void 0 || q.until === void 0 || q.until > q.since,
|
|
347
358
|
"Until must follow since"
|
|
348
359
|
);
|
|
349
|
-
var trackerPageSchema =
|
|
360
|
+
var trackerPageSchema = z3.object({
|
|
350
361
|
tracker: identifier,
|
|
351
|
-
items:
|
|
352
|
-
nextCursor:
|
|
362
|
+
items: z3.array(trackerRecordSchema),
|
|
363
|
+
nextCursor: z3.string().nullable(),
|
|
353
364
|
total: count,
|
|
354
365
|
status: trackerStatusSchema
|
|
355
366
|
});
|
|
356
|
-
var trackerSummarySchema =
|
|
367
|
+
var trackerSummarySchema = z3.object({
|
|
357
368
|
records: count,
|
|
358
369
|
authors: count,
|
|
359
|
-
metrics:
|
|
370
|
+
metrics: z3.object({
|
|
360
371
|
likes: count,
|
|
361
372
|
replies: count,
|
|
362
373
|
reposts: count,
|
|
@@ -372,118 +383,91 @@ var trackerPreviewLimits = {
|
|
|
372
383
|
posts: 100,
|
|
373
384
|
days: 30
|
|
374
385
|
};
|
|
375
|
-
var trackerPreviewInputSchema =
|
|
386
|
+
var trackerPreviewInputSchema = z3.object({
|
|
376
387
|
query: xSearchSourceSchema.shape.query,
|
|
377
388
|
/** Start of the searched window. The window ends when the sample is fetched. */
|
|
378
389
|
since: timestamp
|
|
379
390
|
}).strict();
|
|
380
|
-
var trackerPreviewSchema =
|
|
381
|
-
query:
|
|
391
|
+
var trackerPreviewSchema = z3.object({
|
|
392
|
+
query: z3.string(),
|
|
382
393
|
since: timestamp,
|
|
383
394
|
fetchedAt: timestamp,
|
|
384
395
|
pages: count,
|
|
385
396
|
/** Every match in the sample, newest first, verified or not. */
|
|
386
|
-
posts:
|
|
397
|
+
posts: z3.array(xTweetSchema).max(trackerPreviewLimits.posts),
|
|
387
398
|
/** X had more matches than the sample holds. */
|
|
388
|
-
more:
|
|
399
|
+
more: z3.boolean()
|
|
389
400
|
});
|
|
390
401
|
|
|
391
402
|
// src/content.ts
|
|
392
|
-
|
|
393
|
-
var
|
|
403
|
+
import { z as z4 } from "zod";
|
|
404
|
+
var timestamp2 = z4.number().int().safe().nonnegative().max(864e13);
|
|
405
|
+
var contentPolicySchema = z4.strictObject({
|
|
394
406
|
tracker: identifier,
|
|
395
407
|
window: trackerDefinitionSchema.shape.window,
|
|
396
|
-
enrollment:
|
|
397
|
-
posts:
|
|
398
|
-
historical:
|
|
408
|
+
enrollment: z4.enum(["none", "required"]).default("none"),
|
|
409
|
+
posts: z4.enum(["after-enrollment", "since-start"]).default("after-enrollment"),
|
|
410
|
+
historical: z4.enum(["automatic", "claim", "staff"]).default("claim")
|
|
399
411
|
});
|
|
400
|
-
function content(tracker, policy = {}) {
|
|
401
|
-
if (tracker.source.kind !== "x-search") {
|
|
402
|
-
throw new Error("Content quests require an X tracker");
|
|
403
|
-
}
|
|
404
|
-
return {
|
|
405
|
-
kind: "automatic",
|
|
406
|
-
content: contentPolicySchema.parse({
|
|
407
|
-
tracker: tracker.key,
|
|
408
|
-
window: tracker.window,
|
|
409
|
-
...policy
|
|
410
|
-
})
|
|
411
|
-
};
|
|
412
|
-
}
|
|
413
412
|
var admittedContentSchema = xContentBodySchema.extend({
|
|
414
413
|
tracker: identifier,
|
|
415
414
|
revision: identifier,
|
|
416
415
|
observation: identifier,
|
|
417
416
|
attribution: trackerContentSchema.shape.attribution.options[0],
|
|
418
417
|
enrolledAt: timestamp2.nullable(),
|
|
419
|
-
completionKey:
|
|
418
|
+
completionKey: z4.string().min(1).max(200)
|
|
420
419
|
});
|
|
421
|
-
|
|
422
|
-
return {
|
|
423
|
-
kind: "keyed",
|
|
424
|
-
perContent: true,
|
|
425
|
-
key: (ctx) => {
|
|
426
|
-
if (!ctx.content) {
|
|
427
|
-
throw new Error("perContent requires an admitted content item");
|
|
428
|
-
}
|
|
429
|
-
return ctx.content.completionKey;
|
|
430
|
-
}
|
|
431
|
-
};
|
|
432
|
-
}
|
|
433
|
-
var contentEnrollmentInputSchema = z3.strictObject({
|
|
420
|
+
var contentEnrollmentInputSchema = z4.strictObject({
|
|
434
421
|
actionId: identifier,
|
|
435
422
|
quest: identifier,
|
|
436
423
|
member: identifier
|
|
437
424
|
});
|
|
438
|
-
var contentEnrollmentSchema =
|
|
425
|
+
var contentEnrollmentSchema = z4.strictObject({
|
|
439
426
|
quest: identifier,
|
|
440
427
|
member: identifier,
|
|
441
428
|
enrolledAt: timestamp2
|
|
442
429
|
});
|
|
443
430
|
var contentReleaseInputSchema = contentEnrollmentInputSchema.extend({
|
|
444
|
-
content:
|
|
431
|
+
content: z4.string().min(1).max(256)
|
|
445
432
|
});
|
|
446
|
-
var contentAdmissionSchema =
|
|
433
|
+
var contentAdmissionSchema = z4.strictObject({
|
|
447
434
|
quest: identifier,
|
|
448
|
-
content:
|
|
435
|
+
content: z4.string().min(1).max(256),
|
|
449
436
|
release: identifier,
|
|
450
|
-
state:
|
|
451
|
-
reason:
|
|
437
|
+
state: z4.enum(["pending", "admitted", "excluded"]),
|
|
438
|
+
reason: z4.string().nullable(),
|
|
452
439
|
attempt: identifier.nullable()
|
|
453
440
|
});
|
|
454
|
-
var contentAdmissionQuerySchema =
|
|
441
|
+
var contentAdmissionQuerySchema = z4.strictObject({
|
|
455
442
|
quest: identifier,
|
|
456
443
|
member: identifier.optional(),
|
|
457
|
-
content:
|
|
458
|
-
after:
|
|
444
|
+
content: z4.string().min(1).max(256).optional(),
|
|
445
|
+
after: z4.string().min(1).max(256).optional()
|
|
459
446
|
});
|
|
460
|
-
var contentAdmissionPageSchema =
|
|
461
|
-
items:
|
|
462
|
-
next:
|
|
447
|
+
var contentAdmissionPageSchema = z4.strictObject({
|
|
448
|
+
items: z4.array(contentAdmissionSchema),
|
|
449
|
+
next: z4.string().nullable()
|
|
463
450
|
});
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
var contentQualificationDecisionSchema = z3.strictObject({
|
|
468
|
-
kind: z3.enum(["accept", "reject", "review", "superseded"]),
|
|
469
|
-
reason: z3.string().nullable()
|
|
451
|
+
var contentQualificationDecisionSchema = z4.strictObject({
|
|
452
|
+
kind: z4.enum(["accept", "reject", "review", "superseded"]),
|
|
453
|
+
reason: z4.string().nullable()
|
|
470
454
|
});
|
|
471
|
-
var contentQualificationQuerySchema =
|
|
455
|
+
var contentQualificationQuerySchema = z4.strictObject({
|
|
472
456
|
quest: identifier,
|
|
473
457
|
member: identifier.optional(),
|
|
474
|
-
content:
|
|
475
|
-
before:
|
|
458
|
+
content: z4.string().min(1).max(256).optional(),
|
|
459
|
+
before: z4.coerce.number().int().positive().safe().optional()
|
|
476
460
|
});
|
|
477
|
-
var contentQualificationSchema =
|
|
461
|
+
var contentQualificationSchema = z4.strictObject({
|
|
478
462
|
quest: identifier,
|
|
479
|
-
content:
|
|
463
|
+
content: z4.string(),
|
|
480
464
|
member: identifier,
|
|
481
465
|
release: identifier,
|
|
482
466
|
attempt: identifier,
|
|
483
467
|
revision: identifier,
|
|
484
468
|
observation: identifier,
|
|
485
|
-
current:
|
|
486
|
-
state:
|
|
469
|
+
current: z4.boolean(),
|
|
470
|
+
state: z4.enum([
|
|
487
471
|
"pending",
|
|
488
472
|
"qualified",
|
|
489
473
|
"unqualified",
|
|
@@ -494,18 +478,18 @@ var contentQualificationSchema = z3.strictObject({
|
|
|
494
478
|
"blocked",
|
|
495
479
|
"unavailable"
|
|
496
480
|
]),
|
|
497
|
-
reason:
|
|
498
|
-
reward:
|
|
481
|
+
reason: z4.string().nullable(),
|
|
482
|
+
reward: z4.strictObject({
|
|
499
483
|
attempt: identifier.nullable(),
|
|
500
484
|
completion: identifier.nullable(),
|
|
501
|
-
state:
|
|
485
|
+
state: z4.enum(["unresolved", "awarded", "excluded"])
|
|
502
486
|
})
|
|
503
487
|
});
|
|
504
|
-
var contentQualificationPageSchema =
|
|
505
|
-
items:
|
|
506
|
-
next:
|
|
488
|
+
var contentQualificationPageSchema = z4.strictObject({
|
|
489
|
+
items: z4.array(contentQualificationSchema),
|
|
490
|
+
next: z4.number().int().positive().safe().nullable()
|
|
507
491
|
});
|
|
508
|
-
var contentMetricSchema =
|
|
492
|
+
var contentMetricSchema = z4.enum([
|
|
509
493
|
"likes",
|
|
510
494
|
"replies",
|
|
511
495
|
"reposts",
|
|
@@ -513,21 +497,21 @@ var contentMetricSchema = z3.enum([
|
|
|
513
497
|
"views",
|
|
514
498
|
"bookmarks"
|
|
515
499
|
]);
|
|
516
|
-
var contentMetricsSchema =
|
|
500
|
+
var contentMetricsSchema = z4.partialRecord(
|
|
517
501
|
contentMetricSchema,
|
|
518
|
-
|
|
502
|
+
z4.number().int().safe().nonnegative()
|
|
519
503
|
);
|
|
520
|
-
var contentPerformancePolicySchema =
|
|
521
|
-
metrics:
|
|
504
|
+
var contentPerformancePolicySchema = z4.strictObject({
|
|
505
|
+
metrics: z4.array(contentMetricSchema).min(1).max(6).refine(
|
|
522
506
|
(values) => new Set(values).size === values.length,
|
|
523
507
|
"Metrics must be unique"
|
|
524
508
|
),
|
|
525
|
-
maxAgeMs:
|
|
509
|
+
maxAgeMs: z4.number().int().positive().max(864e5).default(36e5)
|
|
526
510
|
});
|
|
527
511
|
|
|
528
512
|
// src/streaks.ts
|
|
529
|
-
import { z as
|
|
530
|
-
var communityTimeZoneSchema =
|
|
513
|
+
import { z as z5 } from "zod";
|
|
514
|
+
var communityTimeZoneSchema = z5.string().min(1).max(100).refine((zone) => {
|
|
531
515
|
try {
|
|
532
516
|
if (/^[+-]/.test(zone)) {
|
|
533
517
|
return false;
|
|
@@ -538,52 +522,51 @@ var communityTimeZoneSchema = z4.string().min(1).max(100).refine((zone) => {
|
|
|
538
522
|
return false;
|
|
539
523
|
}
|
|
540
524
|
}, "Use an IANA community timezone, such as Europe/Budapest");
|
|
541
|
-
var streakPolicySchema =
|
|
542
|
-
kind:
|
|
543
|
-
days:
|
|
525
|
+
var streakPolicySchema = z5.object({
|
|
526
|
+
kind: z5.literal("streak"),
|
|
527
|
+
days: z5.number().int().min(1).max(3650),
|
|
544
528
|
timeZone: communityTimeZoneSchema
|
|
545
529
|
}).strict();
|
|
546
|
-
var
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
todayQualified: z4.boolean(),
|
|
530
|
+
var streakProgressSchema = z5.object({
|
|
531
|
+
goal: z5.number().int().positive(),
|
|
532
|
+
current: z5.number().int().nonnegative(),
|
|
533
|
+
best: z5.number().int().nonnegative(),
|
|
534
|
+
today: z5.string(),
|
|
535
|
+
todayQualified: z5.boolean(),
|
|
553
536
|
timeZone: communityTimeZoneSchema,
|
|
554
|
-
nextBoundary:
|
|
555
|
-
pendingTimeZone:
|
|
537
|
+
nextBoundary: z5.number().int(),
|
|
538
|
+
pendingTimeZone: z5.object({
|
|
556
539
|
timeZone: communityTimeZoneSchema,
|
|
557
|
-
effectiveAt:
|
|
540
|
+
effectiveAt: z5.number().int()
|
|
558
541
|
}).nullable(),
|
|
559
|
-
days:
|
|
560
|
-
|
|
561
|
-
day:
|
|
562
|
-
date:
|
|
542
|
+
days: z5.array(
|
|
543
|
+
z5.object({
|
|
544
|
+
day: z5.number().int(),
|
|
545
|
+
date: z5.string(),
|
|
563
546
|
timeZone: communityTimeZoneSchema,
|
|
564
|
-
occurredAt:
|
|
547
|
+
occurredAt: z5.number().int()
|
|
565
548
|
})
|
|
566
549
|
),
|
|
567
|
-
milestone:
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
status:
|
|
571
|
-
completion:
|
|
572
|
-
achievedAt:
|
|
550
|
+
milestone: z5.discriminatedUnion("status", [
|
|
551
|
+
z5.object({ status: z5.literal("pending") }),
|
|
552
|
+
z5.object({
|
|
553
|
+
status: z5.literal("awarded"),
|
|
554
|
+
completion: z5.string(),
|
|
555
|
+
achievedAt: z5.number().int()
|
|
573
556
|
}),
|
|
574
|
-
|
|
575
|
-
status:
|
|
576
|
-
budget:
|
|
577
|
-
achievedAt:
|
|
557
|
+
z5.object({
|
|
558
|
+
status: z5.literal("budget-exhausted"),
|
|
559
|
+
budget: z5.string(),
|
|
560
|
+
achievedAt: z5.number().int()
|
|
578
561
|
})
|
|
579
562
|
])
|
|
580
563
|
});
|
|
581
564
|
|
|
582
565
|
// src/tracker-triggers.ts
|
|
583
|
-
import { z as
|
|
584
|
-
var timestamp3 =
|
|
585
|
-
var count2 =
|
|
586
|
-
var trackerTriggerModeSchema =
|
|
566
|
+
import { z as z6 } from "zod";
|
|
567
|
+
var timestamp3 = z6.number().int().safe().nonnegative().max(864e13);
|
|
568
|
+
var count2 = z6.number().int().safe().nonnegative();
|
|
569
|
+
var trackerTriggerModeSchema = z6.enum([
|
|
587
570
|
"new-record",
|
|
588
571
|
"new-observation",
|
|
589
572
|
"data-changed"
|
|
@@ -591,20 +574,20 @@ var trackerTriggerModeSchema = z5.enum([
|
|
|
591
574
|
function defaultTriggerMode(source) {
|
|
592
575
|
return source === "x-search" ? "new-record" : "new-observation";
|
|
593
576
|
}
|
|
594
|
-
var trackerBoundSchema =
|
|
595
|
-
|
|
596
|
-
|
|
577
|
+
var trackerBoundSchema = z6.union([
|
|
578
|
+
z6.number().finite(),
|
|
579
|
+
z6.strictObject({ setting: z6.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
|
|
597
580
|
]);
|
|
598
|
-
var dataPath =
|
|
581
|
+
var dataPath = z6.string().max(200).regex(
|
|
599
582
|
/^[^.\s]+(\.[^.\s]+)*$/,
|
|
600
583
|
"Use dot-separated keys, such as metrics.likes"
|
|
601
584
|
);
|
|
602
|
-
var trackerWhereSchema =
|
|
603
|
-
|
|
585
|
+
var trackerWhereSchema = z6.union([
|
|
586
|
+
z6.strictObject({
|
|
604
587
|
path: dataPath,
|
|
605
|
-
equals:
|
|
588
|
+
equals: z6.union([z6.string().max(1e3), z6.number().finite(), z6.boolean()])
|
|
606
589
|
}),
|
|
607
|
-
|
|
590
|
+
z6.strictObject({
|
|
608
591
|
path: dataPath,
|
|
609
592
|
gt: trackerBoundSchema.optional(),
|
|
610
593
|
gte: trackerBoundSchema.optional(),
|
|
@@ -617,10 +600,10 @@ var trackerWhereSchema = z5.union([
|
|
|
617
600
|
"Compare with equals, gt, gte, lt or lte"
|
|
618
601
|
)
|
|
619
602
|
]);
|
|
620
|
-
var trackerTriggerPolicySchema =
|
|
603
|
+
var trackerTriggerPolicySchema = z6.strictObject({
|
|
621
604
|
/** The tracker's authoring key; publication binds it to the tracker's stable ID. */
|
|
622
605
|
tracker: identifier,
|
|
623
|
-
source:
|
|
606
|
+
source: z6.enum(["x-search", "custom"]),
|
|
624
607
|
/** Which observations fire; absent means the source's default (`defaultTriggerMode`). */
|
|
625
608
|
on: trackerTriggerModeSchema.optional(),
|
|
626
609
|
where: trackerWhereSchema.optional(),
|
|
@@ -629,7 +612,7 @@ var trackerTriggerPolicySchema = z5.strictObject({
|
|
|
629
612
|
* a custom record. Relay attributes it through verified links; evaluators cannot redirect it.
|
|
630
613
|
* Releases published before account roles store `"replied-to"` for `inReplyTo`.
|
|
631
614
|
*/
|
|
632
|
-
beneficiary:
|
|
615
|
+
beneficiary: z6.union([accountRoleSchema, z6.literal("replied-to")])
|
|
633
616
|
});
|
|
634
617
|
function triggerMode(policy) {
|
|
635
618
|
return policy.on ?? defaultTriggerMode(policy.source);
|
|
@@ -638,52 +621,52 @@ function beneficiaryRole(policy) {
|
|
|
638
621
|
return policy.beneficiary === "replied-to" ? "inReplyTo" : policy.beneficiary;
|
|
639
622
|
}
|
|
640
623
|
var xLink = {
|
|
641
|
-
issuer:
|
|
624
|
+
issuer: z6.string().min(1),
|
|
642
625
|
/** The account's stable user ID. */
|
|
643
|
-
subject:
|
|
626
|
+
subject: z6.string().min(1).max(256),
|
|
644
627
|
/** The member's account selection revision. */
|
|
645
628
|
revision: count2,
|
|
646
629
|
/** When the member linked the account; null when unknown. */
|
|
647
630
|
linkedAt: timestamp3.nullable()
|
|
648
631
|
};
|
|
649
|
-
var trackerAttributionSchema =
|
|
632
|
+
var trackerAttributionSchema = z6.strictObject({
|
|
650
633
|
member: identifier,
|
|
651
634
|
capturedAt: timestamp3,
|
|
652
|
-
account:
|
|
653
|
-
|
|
654
|
-
provider:
|
|
635
|
+
account: z6.discriminatedUnion("provider", [
|
|
636
|
+
z6.strictObject({
|
|
637
|
+
provider: z6.literal("wallet"),
|
|
655
638
|
/** Canonical CAIP-10 account ID, as the record names it. */
|
|
656
|
-
id:
|
|
639
|
+
id: z6.string().min(5).max(256),
|
|
657
640
|
/** The wallet link's revision. */
|
|
658
641
|
revision: count2,
|
|
659
642
|
/** When the member verified the wallet. */
|
|
660
643
|
linkedAt: timestamp3.nullable()
|
|
661
644
|
}),
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
provider:
|
|
645
|
+
z6.strictObject({ provider: z6.literal("x"), ...xLink }),
|
|
646
|
+
z6.strictObject({ provider: z6.literal("discord"), ...xLink }),
|
|
647
|
+
z6.strictObject({
|
|
648
|
+
provider: z6.literal("member"),
|
|
666
649
|
/** The member ID the record names. */
|
|
667
650
|
id: identifier
|
|
668
651
|
})
|
|
669
652
|
])
|
|
670
653
|
});
|
|
671
|
-
var trackerTriggerRecordSchema =
|
|
672
|
-
id:
|
|
673
|
-
source:
|
|
654
|
+
var trackerTriggerRecordSchema = z6.strictObject({
|
|
655
|
+
id: z6.string().min(1).max(256),
|
|
656
|
+
source: z6.string(),
|
|
674
657
|
occurredAt: timestamp3,
|
|
675
658
|
observedAt: timestamp3,
|
|
676
659
|
firstSeenAt: timestamp3,
|
|
677
|
-
author:
|
|
678
|
-
id:
|
|
679
|
-
verified:
|
|
660
|
+
author: z6.strictObject({
|
|
661
|
+
id: z6.string().min(1).max(256),
|
|
662
|
+
verified: z6.boolean().nullable(),
|
|
680
663
|
kind: identityKindSchema.optional()
|
|
681
664
|
}).nullable(),
|
|
682
|
-
accounts:
|
|
683
|
-
data:
|
|
684
|
-
removed:
|
|
665
|
+
accounts: z6.record(accountRoleSchema, trackerAccountSchema).optional(),
|
|
666
|
+
data: z6.record(z6.string(), z6.json()),
|
|
667
|
+
removed: z6.boolean()
|
|
685
668
|
});
|
|
686
|
-
var trackerTriggerContextSchema =
|
|
669
|
+
var trackerTriggerContextSchema = z6.strictObject({
|
|
687
670
|
/** The tracker's stable ID. */
|
|
688
671
|
tracker: identifier,
|
|
689
672
|
/** The tracker's authoring key. */
|
|
@@ -692,10 +675,10 @@ var trackerTriggerContextSchema = z5.strictObject({
|
|
|
692
675
|
* The record account the attempt pays, as the quest's release names it. Releases published
|
|
693
676
|
* before account roles name `inReplyTo` `"replied-to"`, which their bundled evaluators expect.
|
|
694
677
|
*/
|
|
695
|
-
beneficiary:
|
|
678
|
+
beneficiary: z6.union([accountRoleSchema, z6.literal("replied-to")]),
|
|
696
679
|
record: trackerTriggerRecordSchema,
|
|
697
680
|
/** The captured X post of this observation; null for custom trackers. */
|
|
698
|
-
x:
|
|
681
|
+
x: z6.strictObject({
|
|
699
682
|
evidence: trackerEvidenceSchema,
|
|
700
683
|
content: xContentBodySchema
|
|
701
684
|
}).nullable(),
|
|
@@ -703,111 +686,86 @@ var trackerTriggerContextSchema = z5.strictObject({
|
|
|
703
686
|
});
|
|
704
687
|
|
|
705
688
|
// src/observations.ts
|
|
706
|
-
import { z as
|
|
707
|
-
var name =
|
|
708
|
-
var observationInputSchema =
|
|
689
|
+
import { z as z7 } from "zod";
|
|
690
|
+
var name = z7.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
|
|
691
|
+
var observationInputSchema = z7.object({
|
|
709
692
|
id: name,
|
|
710
693
|
source: name,
|
|
711
694
|
type: name,
|
|
712
695
|
member: identifier,
|
|
713
|
-
actor:
|
|
714
|
-
occurredAt:
|
|
715
|
-
data:
|
|
696
|
+
actor: z7.object({ provider: identifier, subject: z7.string().min(1).max(200) }).strict().optional(),
|
|
697
|
+
occurredAt: z7.number().int().nonnegative().max(864e13),
|
|
698
|
+
data: z7.record(z7.string(), z7.json())
|
|
716
699
|
}).strict().refine(
|
|
717
700
|
(value) => JSON.stringify(value.data).length <= 32768,
|
|
718
701
|
"Observation data exceeds 32 KB"
|
|
719
702
|
);
|
|
720
703
|
var observationSchema = observationInputSchema.safeExtend({
|
|
721
|
-
receivedAt:
|
|
704
|
+
receivedAt: z7.number().int().nonnegative()
|
|
722
705
|
});
|
|
723
|
-
var observationTriggerSchema =
|
|
724
|
-
var completionPolicySchema =
|
|
706
|
+
var observationTriggerSchema = z7.object({ source: name, type: name }).strict();
|
|
707
|
+
var completionPolicySchema = z7.discriminatedUnion("kind", [
|
|
725
708
|
streakPolicySchema,
|
|
726
|
-
|
|
727
|
-
|
|
709
|
+
z7.object({ kind: z7.literal("once") }).strict(),
|
|
710
|
+
z7.object({ kind: z7.literal("keyed") }).strict()
|
|
728
711
|
]);
|
|
729
|
-
var completionKeySchema =
|
|
730
|
-
var budgetSchema =
|
|
712
|
+
var completionKeySchema = z7.string().min(1).max(500);
|
|
713
|
+
var budgetSchema = z7.object({
|
|
731
714
|
id: name,
|
|
732
|
-
scope:
|
|
715
|
+
scope: z7.enum(["member", "project"]),
|
|
733
716
|
/**
|
|
734
717
|
* `"day"` buckets by UTC date and `"week"` by ISO week (UTC, weeks start on Monday), both of
|
|
735
718
|
* the attempt's eligibility time; `"lifetime"` never resets.
|
|
736
719
|
*/
|
|
737
|
-
period:
|
|
738
|
-
limit:
|
|
739
|
-
cost:
|
|
740
|
-
|
|
741
|
-
|
|
720
|
+
period: z7.enum(["lifetime", "day", "week"]),
|
|
721
|
+
limit: z7.number().int().positive().max(Number.MAX_SAFE_INTEGER),
|
|
722
|
+
cost: z7.union([
|
|
723
|
+
z7.number().int().positive().max(Number.MAX_SAFE_INTEGER),
|
|
724
|
+
z7.object({ balance: name }).strict()
|
|
742
725
|
])
|
|
743
726
|
}).strict();
|
|
744
|
-
var observationReceiptSchema =
|
|
727
|
+
var observationReceiptSchema = z7.object({
|
|
745
728
|
id: name,
|
|
746
729
|
source: name,
|
|
747
|
-
attempts:
|
|
748
|
-
receivedAt:
|
|
730
|
+
attempts: z7.array(z7.string()),
|
|
731
|
+
receivedAt: z7.number()
|
|
749
732
|
});
|
|
750
|
-
var discordReactionSchema =
|
|
751
|
-
guildId:
|
|
752
|
-
channelId:
|
|
753
|
-
messageId:
|
|
754
|
-
userId:
|
|
755
|
-
messageAuthorId:
|
|
756
|
-
actorRoles:
|
|
757
|
-
emoji:
|
|
758
|
-
messagePublishedAt:
|
|
733
|
+
var discordReactionSchema = z7.object({
|
|
734
|
+
guildId: z7.string(),
|
|
735
|
+
channelId: z7.string(),
|
|
736
|
+
messageId: z7.string(),
|
|
737
|
+
userId: z7.string(),
|
|
738
|
+
messageAuthorId: z7.string().nullable().default(null),
|
|
739
|
+
actorRoles: z7.array(z7.string()).default([]),
|
|
740
|
+
emoji: z7.object({ id: z7.string().nullable(), name: z7.string() }),
|
|
741
|
+
messagePublishedAt: z7.number()
|
|
759
742
|
}).strict();
|
|
760
|
-
var discordMessageSchema =
|
|
761
|
-
guildId:
|
|
762
|
-
channelId:
|
|
763
|
-
messageId:
|
|
764
|
-
userId:
|
|
765
|
-
content:
|
|
766
|
-
replyTo:
|
|
767
|
-
publishedAt:
|
|
743
|
+
var discordMessageSchema = z7.object({
|
|
744
|
+
guildId: z7.string(),
|
|
745
|
+
channelId: z7.string(),
|
|
746
|
+
messageId: z7.string(),
|
|
747
|
+
userId: z7.string(),
|
|
748
|
+
content: z7.string().nullable(),
|
|
749
|
+
replyTo: z7.string().nullable(),
|
|
750
|
+
publishedAt: z7.number()
|
|
768
751
|
}).strict();
|
|
769
752
|
|
|
770
753
|
// src/integrations.ts
|
|
771
|
-
import { z as
|
|
772
|
-
var integrationProviderSchema =
|
|
773
|
-
var discordServerSchema =
|
|
774
|
-
id:
|
|
775
|
-
name:
|
|
776
|
-
icon:
|
|
754
|
+
import { z as z8 } from "zod";
|
|
755
|
+
var integrationProviderSchema = z8.enum(["discord"]);
|
|
756
|
+
var discordServerSchema = z8.object({
|
|
757
|
+
id: z8.string().regex(/^[0-9]{1,20}$/),
|
|
758
|
+
name: z8.string().min(1),
|
|
759
|
+
icon: z8.string().nullable()
|
|
777
760
|
});
|
|
778
|
-
var projectIntegrationSchema =
|
|
761
|
+
var projectIntegrationSchema = z8.object({
|
|
779
762
|
provider: integrationProviderSchema,
|
|
780
|
-
configured: z7.boolean(),
|
|
781
|
-
status: z7.enum(["disconnected", "ready", "attention"]),
|
|
782
|
-
revision: z7.number().int().nonnegative(),
|
|
783
|
-
server: discordServerSchema.nullable(),
|
|
784
|
-
issue: z7.string().nullable(),
|
|
785
|
-
connectedAt: z7.number().default(0)
|
|
786
|
-
});
|
|
787
|
-
|
|
788
|
-
// src/accounts.ts
|
|
789
|
-
import { z as z8 } from "zod";
|
|
790
|
-
var authProviderSchema = z8.enum(["google", "apple", "x", "discord"]);
|
|
791
|
-
var accountConnectionSchema = z8.object({
|
|
792
|
-
provider: authProviderSchema,
|
|
793
763
|
configured: z8.boolean(),
|
|
794
|
-
status: z8.enum(["disconnected", "
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
var discordMessageInputSchema = z8.object({
|
|
800
|
-
channelId: z8.string().regex(/^[0-9]{1,20}$/),
|
|
801
|
-
messageId: z8.string().regex(/^[0-9]{1,20}$/)
|
|
802
|
-
}).strict();
|
|
803
|
-
var discordMemberSchema = z8.object({
|
|
804
|
-
userId: z8.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
|
|
805
|
-
nickname: z8.string().nullable().default(null),
|
|
806
|
-
displayName: z8.string().nullable().default(null),
|
|
807
|
-
boostingSince: z8.string().datetime({ offset: true }).nullable().default(null),
|
|
808
|
-
roles: z8.array(z8.string().regex(/^[0-9]{1,20}$/)),
|
|
809
|
-
joinedAt: z8.string().datetime({ offset: true }).nullable(),
|
|
810
|
-
pending: z8.boolean()
|
|
764
|
+
status: z8.enum(["disconnected", "ready", "attention"]),
|
|
765
|
+
revision: z8.number().int().nonnegative(),
|
|
766
|
+
server: discordServerSchema.nullable(),
|
|
767
|
+
issue: z8.string().nullable(),
|
|
768
|
+
connectedAt: z8.number().default(0)
|
|
811
769
|
});
|
|
812
770
|
|
|
813
771
|
// src/submission-input.ts
|
|
@@ -925,12 +883,6 @@ var quizContentSchema = z10.array(
|
|
|
925
883
|
"Question IDs must be unique"
|
|
926
884
|
);
|
|
927
885
|
|
|
928
|
-
// src/schema.ts
|
|
929
|
-
import { z as z13 } from "zod";
|
|
930
|
-
|
|
931
|
-
// src/settings.ts
|
|
932
|
-
import { z as z12 } from "zod";
|
|
933
|
-
|
|
934
886
|
// src/resources.ts
|
|
935
887
|
import { z as z11 } from "zod";
|
|
936
888
|
var channelSourceSchema = z11.object({
|
|
@@ -969,125 +921,61 @@ var resourceOptionsSchema = z11.object({
|
|
|
969
921
|
),
|
|
970
922
|
cursor: z11.string().nullable()
|
|
971
923
|
});
|
|
972
|
-
var discord = {
|
|
973
|
-
roles(options = {}) {
|
|
974
|
-
return resourceSourceSchema.parse({
|
|
975
|
-
provider: "discord",
|
|
976
|
-
resource: "role",
|
|
977
|
-
assignable: options.assignable ?? false
|
|
978
|
-
});
|
|
979
|
-
},
|
|
980
|
-
channels(options = {}) {
|
|
981
|
-
return resourceSourceSchema.parse({
|
|
982
|
-
provider: "discord",
|
|
983
|
-
resource: "channel",
|
|
984
|
-
types: options.types ?? ["text", "announcement"]
|
|
985
|
-
});
|
|
986
|
-
}
|
|
987
|
-
};
|
|
988
|
-
var pointLedgers = () => ({
|
|
989
|
-
provider: "domino",
|
|
990
|
-
resource: "point-ledger"
|
|
991
|
-
});
|
|
992
924
|
|
|
993
925
|
// src/settings.ts
|
|
994
|
-
|
|
995
|
-
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
z12.
|
|
926
|
+
import { z as z13 } from "zod";
|
|
927
|
+
|
|
928
|
+
// src/setting-values.ts
|
|
929
|
+
import { z as z12 } from "zod";
|
|
930
|
+
var settingInstant = z12.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
|
|
931
|
+
var settingResourceId = z12.union([
|
|
932
|
+
z12.literal(""),
|
|
933
|
+
z12.string().regex(/^\S{1,200}$/)
|
|
934
|
+
]);
|
|
935
|
+
|
|
936
|
+
// src/settings.ts
|
|
937
|
+
var base = { label: z13.string().min(1), description: z13.string().optional() };
|
|
938
|
+
var settingFieldSchema = z13.discriminatedUnion("kind", [
|
|
939
|
+
z13.object({ ...base, kind: z13.literal("point-ledger"), default: identifier }).strict(),
|
|
940
|
+
z13.object({ ...base, kind: z13.literal("datetime"), default: settingInstant }).strict(),
|
|
941
|
+
z13.object({
|
|
1001
942
|
...base,
|
|
1002
|
-
kind:
|
|
1003
|
-
default:
|
|
943
|
+
kind: z13.literal("resource"),
|
|
944
|
+
default: settingResourceId,
|
|
1004
945
|
source: resourceSourceSchema
|
|
1005
946
|
}).strict(),
|
|
1006
|
-
|
|
1007
|
-
|
|
947
|
+
z13.object({ ...base, kind: z13.literal("quiz"), default: quizContentSchema }).strict(),
|
|
948
|
+
z13.object({
|
|
1008
949
|
...base,
|
|
1009
|
-
kind:
|
|
1010
|
-
default:
|
|
1011
|
-
minLength:
|
|
1012
|
-
maxLength:
|
|
1013
|
-
multiline:
|
|
950
|
+
kind: z13.literal("text"),
|
|
951
|
+
default: z13.string(),
|
|
952
|
+
minLength: z13.number().int().nonnegative(),
|
|
953
|
+
maxLength: z13.number().int().positive(),
|
|
954
|
+
multiline: z13.boolean()
|
|
1014
955
|
}).strict(),
|
|
1015
|
-
|
|
956
|
+
z13.object({
|
|
1016
957
|
...base,
|
|
1017
|
-
kind:
|
|
1018
|
-
default:
|
|
1019
|
-
min:
|
|
1020
|
-
max:
|
|
958
|
+
kind: z13.literal("integer"),
|
|
959
|
+
default: z13.number().int(),
|
|
960
|
+
min: z13.number().int(),
|
|
961
|
+
max: z13.number().int()
|
|
1021
962
|
}).strict(),
|
|
1022
|
-
|
|
1023
|
-
|
|
963
|
+
z13.object({ ...base, kind: z13.literal("boolean"), default: z13.boolean() }).strict(),
|
|
964
|
+
z13.object({
|
|
1024
965
|
...base,
|
|
1025
|
-
kind:
|
|
1026
|
-
default:
|
|
1027
|
-
options:
|
|
966
|
+
kind: z13.literal("choice"),
|
|
967
|
+
default: z13.string(),
|
|
968
|
+
options: z13.array(z13.string().min(1)).min(1)
|
|
1028
969
|
}).strict()
|
|
1029
970
|
]);
|
|
1030
|
-
var settingsFieldsSchema =
|
|
1031
|
-
|
|
971
|
+
var settingsFieldsSchema = z13.record(
|
|
972
|
+
z13.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
|
|
1032
973
|
settingFieldSchema
|
|
1033
974
|
);
|
|
1034
|
-
var settingsValuesSchema =
|
|
1035
|
-
|
|
1036
|
-
|
|
975
|
+
var settingsValuesSchema = z13.record(
|
|
976
|
+
z13.string(),
|
|
977
|
+
z13.union([z13.string(), z13.number().finite(), z13.boolean(), quizContentSchema])
|
|
1037
978
|
);
|
|
1038
|
-
var settings = {
|
|
1039
|
-
pointLedger(options) {
|
|
1040
|
-
const field = {
|
|
1041
|
-
...options,
|
|
1042
|
-
kind: "point-ledger",
|
|
1043
|
-
default: identifier.parse(options.default)
|
|
1044
|
-
};
|
|
1045
|
-
return identifier.default(field.default).meta(field);
|
|
1046
|
-
},
|
|
1047
|
-
datetime(options) {
|
|
1048
|
-
const field = {
|
|
1049
|
-
...options,
|
|
1050
|
-
kind: "datetime",
|
|
1051
|
-
default: instant.parse(options.default)
|
|
1052
|
-
};
|
|
1053
|
-
return instant.default(field.default).meta(field);
|
|
1054
|
-
},
|
|
1055
|
-
resource(options) {
|
|
1056
|
-
const field = {
|
|
1057
|
-
...options,
|
|
1058
|
-
source: resourceSourceSchema.parse(options.source),
|
|
1059
|
-
kind: "resource",
|
|
1060
|
-
default: resourceId.parse(options.default ?? "")
|
|
1061
|
-
};
|
|
1062
|
-
return resourceId.default(field.default).meta(field);
|
|
1063
|
-
},
|
|
1064
|
-
quiz(options) {
|
|
1065
|
-
const value = quizContentSchema.parse(options.default);
|
|
1066
|
-
return quizContentSchema.default(value).meta({ ...options, default: value, kind: "quiz" });
|
|
1067
|
-
},
|
|
1068
|
-
text(options) {
|
|
1069
|
-
const field = {
|
|
1070
|
-
...options,
|
|
1071
|
-
kind: "text",
|
|
1072
|
-
minLength: options.minLength ?? 1,
|
|
1073
|
-
maxLength: options.maxLength ?? 2e3,
|
|
1074
|
-
multiline: options.multiline ?? false
|
|
1075
|
-
};
|
|
1076
|
-
return z12.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
|
|
1077
|
-
},
|
|
1078
|
-
integer(options) {
|
|
1079
|
-
return z12.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
|
|
1080
|
-
},
|
|
1081
|
-
boolean(options) {
|
|
1082
|
-
return z12.boolean().default(options.default).meta({ ...options, kind: "boolean" });
|
|
1083
|
-
},
|
|
1084
|
-
choice(options) {
|
|
1085
|
-
return z12.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
|
|
1086
|
-
},
|
|
1087
|
-
object(shape) {
|
|
1088
|
-
return z12.object(shape).strict();
|
|
1089
|
-
}
|
|
1090
|
-
};
|
|
1091
979
|
function parseSettings(fields, input) {
|
|
1092
980
|
const shape = {};
|
|
1093
981
|
for (const [key, field] of Object.entries(fields)) {
|
|
@@ -1096,29 +984,29 @@ function parseSettings(fields, input) {
|
|
|
1096
984
|
shape[key] = identifier.default(field.default);
|
|
1097
985
|
break;
|
|
1098
986
|
case "datetime":
|
|
1099
|
-
shape[key] =
|
|
987
|
+
shape[key] = settingInstant.default(field.default);
|
|
1100
988
|
break;
|
|
1101
989
|
case "resource":
|
|
1102
|
-
shape[key] =
|
|
990
|
+
shape[key] = settingResourceId.default(field.default);
|
|
1103
991
|
break;
|
|
1104
992
|
case "quiz":
|
|
1105
993
|
shape[key] = quizContentSchema.default(field.default);
|
|
1106
994
|
break;
|
|
1107
995
|
case "text":
|
|
1108
|
-
shape[key] =
|
|
996
|
+
shape[key] = z13.string().min(field.minLength).max(field.maxLength).default(field.default);
|
|
1109
997
|
break;
|
|
1110
998
|
case "integer":
|
|
1111
|
-
shape[key] =
|
|
999
|
+
shape[key] = z13.number().int().min(field.min).max(field.max).default(field.default);
|
|
1112
1000
|
break;
|
|
1113
1001
|
case "boolean":
|
|
1114
|
-
shape[key] =
|
|
1002
|
+
shape[key] = z13.boolean().default(field.default);
|
|
1115
1003
|
break;
|
|
1116
1004
|
case "choice":
|
|
1117
|
-
shape[key] =
|
|
1005
|
+
shape[key] = z13.enum(field.options).default(field.default);
|
|
1118
1006
|
break;
|
|
1119
1007
|
}
|
|
1120
1008
|
}
|
|
1121
|
-
return settingsValuesSchema.parse(
|
|
1009
|
+
return settingsValuesSchema.parse(z13.object(shape).strict().parse(input));
|
|
1122
1010
|
}
|
|
1123
1011
|
function missingResourceSettings(fields, values) {
|
|
1124
1012
|
return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
|
|
@@ -1128,42 +1016,43 @@ function compatibleSettingKinds(previous, next) {
|
|
|
1128
1016
|
}
|
|
1129
1017
|
|
|
1130
1018
|
// src/schema.ts
|
|
1131
|
-
|
|
1132
|
-
|
|
1019
|
+
import { z as z14 } from "zod";
|
|
1020
|
+
var pointsRewardSchema = z14.object({
|
|
1021
|
+
kind: z14.literal("points").default("points"),
|
|
1133
1022
|
balance: identifier,
|
|
1134
|
-
amount:
|
|
1023
|
+
amount: z14.number().int().min(0).max(1e4)
|
|
1135
1024
|
}).strict();
|
|
1136
|
-
var tieredRewardDefinitionSchema =
|
|
1025
|
+
var tieredRewardDefinitionSchema = z14.object({
|
|
1137
1026
|
id: identifier,
|
|
1138
|
-
title:
|
|
1139
|
-
tiers:
|
|
1140
|
-
|
|
1027
|
+
title: z14.string().min(1).max(120),
|
|
1028
|
+
tiers: z14.array(
|
|
1029
|
+
z14.object({ id: identifier, title: z14.string().min(1).max(120) }).strict()
|
|
1141
1030
|
).min(1).max(20).refine(
|
|
1142
1031
|
(tiers) => new Set(tiers.map((t) => t.id)).size === tiers.length,
|
|
1143
1032
|
"Tier IDs must be unique"
|
|
1144
1033
|
),
|
|
1145
|
-
inventory:
|
|
1146
|
-
fulfillment:
|
|
1034
|
+
inventory: z14.object({ kind: z14.literal("untracked") }).strict(),
|
|
1035
|
+
fulfillment: z14.object({ kind: z14.literal("staff-handover") }).strict()
|
|
1147
1036
|
}).strict();
|
|
1148
|
-
var tieredRewardReferenceSchema =
|
|
1037
|
+
var tieredRewardReferenceSchema = z14.object({
|
|
1149
1038
|
id: identifier,
|
|
1150
1039
|
key: identifier.nullable()
|
|
1151
1040
|
});
|
|
1152
|
-
var tierRewardSchema =
|
|
1153
|
-
kind:
|
|
1041
|
+
var tierRewardSchema = z14.object({
|
|
1042
|
+
kind: z14.literal("tier"),
|
|
1154
1043
|
reward: tieredRewardDefinitionSchema,
|
|
1155
1044
|
tier: identifier
|
|
1156
1045
|
}).strict().refine(
|
|
1157
1046
|
(value) => value.reward.tiers.some((t) => t.id === value.tier),
|
|
1158
1047
|
"Unknown reward tier"
|
|
1159
1048
|
);
|
|
1160
|
-
var integrationRewardSchema =
|
|
1161
|
-
kind:
|
|
1162
|
-
provider:
|
|
1163
|
-
action:
|
|
1164
|
-
roleId:
|
|
1049
|
+
var integrationRewardSchema = z14.object({
|
|
1050
|
+
kind: z14.literal("integration"),
|
|
1051
|
+
provider: z14.literal("discord"),
|
|
1052
|
+
action: z14.literal("grant-role"),
|
|
1053
|
+
roleId: z14.string().regex(/^[0-9]{1,20}$/)
|
|
1165
1054
|
}).strict();
|
|
1166
|
-
var rewardSchema =
|
|
1055
|
+
var rewardSchema = z14.union([
|
|
1167
1056
|
pointsRewardSchema,
|
|
1168
1057
|
tierRewardSchema,
|
|
1169
1058
|
integrationRewardSchema
|
|
@@ -1174,26 +1063,26 @@ function rewardKey(reward) {
|
|
|
1174
1063
|
}
|
|
1175
1064
|
return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
|
|
1176
1065
|
}
|
|
1177
|
-
var triggerSchema =
|
|
1178
|
-
|
|
1179
|
-
kind:
|
|
1180
|
-
input:
|
|
1066
|
+
var triggerSchema = z14.union([
|
|
1067
|
+
z14.object({
|
|
1068
|
+
kind: z14.literal("manual"),
|
|
1069
|
+
input: z14.literal("text"),
|
|
1181
1070
|
constraints: textOptionsSchema,
|
|
1182
|
-
actor:
|
|
1071
|
+
actor: z14.enum(["member", "staff"]).optional()
|
|
1183
1072
|
}).strict(),
|
|
1184
|
-
|
|
1185
|
-
kind:
|
|
1186
|
-
input:
|
|
1073
|
+
z14.object({
|
|
1074
|
+
kind: z14.literal("manual"),
|
|
1075
|
+
input: z14.literal("url"),
|
|
1187
1076
|
constraints: urlOptionsSchema,
|
|
1188
|
-
actor:
|
|
1077
|
+
actor: z14.enum(["member", "staff"]).optional()
|
|
1189
1078
|
}).strict(),
|
|
1190
|
-
|
|
1191
|
-
kind:
|
|
1192
|
-
input:
|
|
1193
|
-
actor:
|
|
1079
|
+
z14.object({
|
|
1080
|
+
kind: z14.literal("manual"),
|
|
1081
|
+
input: z14.enum(["photo", "quiz", "none"]),
|
|
1082
|
+
actor: z14.enum(["member", "staff"]).optional()
|
|
1194
1083
|
}).strict(),
|
|
1195
|
-
|
|
1196
|
-
kind:
|
|
1084
|
+
z14.object({
|
|
1085
|
+
kind: z14.literal("automatic"),
|
|
1197
1086
|
observation: observationTriggerSchema.optional(),
|
|
1198
1087
|
content: contentPolicySchema.optional(),
|
|
1199
1088
|
tracker: trackerTriggerPolicySchema.optional()
|
|
@@ -1202,43 +1091,48 @@ var triggerSchema = z13.union([
|
|
|
1202
1091
|
"Choose one automatic trigger source"
|
|
1203
1092
|
)
|
|
1204
1093
|
]);
|
|
1205
|
-
var prerequisiteSchema =
|
|
1206
|
-
var photoResultSchema =
|
|
1207
|
-
kind:
|
|
1208
|
-
reason:
|
|
1094
|
+
var prerequisiteSchema = z14.object({ quest: identifier });
|
|
1095
|
+
var photoResultSchema = z14.object({
|
|
1096
|
+
kind: z14.enum(["pass", "fail", "unclear"]),
|
|
1097
|
+
reason: z14.string().min(1).max(2e3)
|
|
1209
1098
|
}).strict();
|
|
1210
|
-
var textReviewInputSchema =
|
|
1211
|
-
text:
|
|
1212
|
-
criteria:
|
|
1099
|
+
var textReviewInputSchema = z14.object({
|
|
1100
|
+
text: z14.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
|
|
1101
|
+
criteria: z14.string().trim().min(1).max(2e3)
|
|
1213
1102
|
}).strict();
|
|
1214
1103
|
var textResultSchema = photoResultSchema;
|
|
1215
|
-
var decisionSchema =
|
|
1216
|
-
|
|
1217
|
-
kind:
|
|
1218
|
-
rewards:
|
|
1104
|
+
var decisionSchema = z14.discriminatedUnion("kind", [
|
|
1105
|
+
z14.object({
|
|
1106
|
+
kind: z14.literal("accept"),
|
|
1107
|
+
rewards: z14.array(rewardSchema).max(10),
|
|
1219
1108
|
completionKey: completionKeySchema.optional()
|
|
1220
1109
|
}).strict(),
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
1224
|
-
|
|
1225
|
-
|
|
1110
|
+
z14.object({
|
|
1111
|
+
kind: z14.literal("reject"),
|
|
1112
|
+
reason: z14.string().min(1).max(2e3),
|
|
1113
|
+
/** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
|
|
1114
|
+
requestedReview: z14.literal(true).optional()
|
|
1115
|
+
}).strict(),
|
|
1116
|
+
z14.object({
|
|
1117
|
+
kind: z14.literal("review"),
|
|
1118
|
+
reason: z14.string().min(1).max(2e3),
|
|
1119
|
+
rewards: z14.array(rewardSchema).max(10).optional(),
|
|
1226
1120
|
completionKey: completionKeySchema.optional()
|
|
1227
1121
|
}).strict()
|
|
1228
1122
|
]);
|
|
1229
|
-
var reviewModeSchema =
|
|
1230
|
-
var storedReviewModeSchema =
|
|
1123
|
+
var reviewModeSchema = z14.enum(["workers-ai"]);
|
|
1124
|
+
var storedReviewModeSchema = z14.enum([
|
|
1231
1125
|
"fixture-pass",
|
|
1232
1126
|
"fixture-fail",
|
|
1233
1127
|
"fixture-unclear",
|
|
1234
1128
|
"fixture-error",
|
|
1235
1129
|
"workers-ai"
|
|
1236
1130
|
]);
|
|
1237
|
-
var rewardBundleSchema =
|
|
1131
|
+
var rewardBundleSchema = z14.array(rewardSchema).max(10).refine(
|
|
1238
1132
|
(rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
|
|
1239
1133
|
"Use one entry per balance or shared reward"
|
|
1240
1134
|
);
|
|
1241
|
-
var mediaUrlSchema =
|
|
1135
|
+
var mediaUrlSchema = z14.string().max(2e3).refine((value) => {
|
|
1242
1136
|
if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
|
|
1243
1137
|
return true;
|
|
1244
1138
|
}
|
|
@@ -1248,82 +1142,82 @@ var mediaUrlSchema = z13.string().max(2e3).refine((value) => {
|
|
|
1248
1142
|
return false;
|
|
1249
1143
|
}
|
|
1250
1144
|
}, "Use an HTTPS URL or a same-site path beginning with /");
|
|
1251
|
-
var questPresentationSchema =
|
|
1145
|
+
var questPresentationSchema = z14.object({
|
|
1252
1146
|
quiz: quizQuestionsSchema.optional(),
|
|
1253
|
-
instructions:
|
|
1254
|
-
video:
|
|
1147
|
+
instructions: z14.string().max(4e3).optional(),
|
|
1148
|
+
video: z14.object({
|
|
1255
1149
|
url: mediaUrlSchema,
|
|
1256
1150
|
poster: mediaUrlSchema.optional(),
|
|
1257
|
-
captions:
|
|
1151
|
+
captions: z14.object({
|
|
1258
1152
|
url: mediaUrlSchema,
|
|
1259
|
-
language:
|
|
1260
|
-
label:
|
|
1153
|
+
language: z14.string().min(2).max(20),
|
|
1154
|
+
label: z14.string().min(1).max(80)
|
|
1261
1155
|
}).strict().optional()
|
|
1262
1156
|
}).strict().optional()
|
|
1263
1157
|
}).strict();
|
|
1264
|
-
var questProfileSchema =
|
|
1265
|
-
var questDescriptionSchema =
|
|
1158
|
+
var questProfileSchema = z14.object({ visible: z14.boolean() }).strict();
|
|
1159
|
+
var questDescriptionSchema = z14.object({
|
|
1266
1160
|
quest: identifier,
|
|
1267
|
-
runtimeVersion:
|
|
1268
|
-
title:
|
|
1161
|
+
runtimeVersion: z14.union([z14.literal(1), z14.literal(2)]).default(1),
|
|
1162
|
+
title: z14.string().min(1).max(120),
|
|
1269
1163
|
presentation: questPresentationSchema.default({}),
|
|
1270
|
-
integrations:
|
|
1164
|
+
integrations: z14.array(integrationProviderSchema).max(10).default([]),
|
|
1271
1165
|
fields: settingsFieldsSchema,
|
|
1272
1166
|
values: settingsValuesSchema,
|
|
1273
1167
|
rewards: rewardBundleSchema,
|
|
1274
|
-
humanReview:
|
|
1168
|
+
humanReview: z14.boolean(),
|
|
1275
1169
|
trigger: triggerSchema,
|
|
1276
1170
|
performance: contentPerformancePolicySchema.optional(),
|
|
1277
|
-
requires:
|
|
1171
|
+
requires: z14.array(prerequisiteSchema).max(30).default([]),
|
|
1278
1172
|
completion: completionPolicySchema,
|
|
1279
|
-
visibility:
|
|
1173
|
+
visibility: z14.enum(["visible", "hidden"]).default("visible"),
|
|
1280
1174
|
/**
|
|
1281
1175
|
* Whether completions show on participant profiles (`/v1/profiles/:id/completions`). Absent
|
|
1282
1176
|
* is hidden. Optional, not defaulted: releases carry the key only when the author sets it, so
|
|
1283
1177
|
* clients and pods that predate it (strict release schemas) still read every other release.
|
|
1284
1178
|
*/
|
|
1285
1179
|
profile: questProfileSchema.optional(),
|
|
1286
|
-
budgets:
|
|
1180
|
+
budgets: z14.array(budgetSchema).max(20).default([])
|
|
1287
1181
|
}).strict();
|
|
1288
|
-
var artifactSchema =
|
|
1182
|
+
var artifactSchema = z14.object({ code: z14.string().min(1).max(1e6) }).strict();
|
|
1289
1183
|
var releaseSchema = artifactSchema.extend({
|
|
1290
1184
|
settings: settingsValuesSchema,
|
|
1291
1185
|
provider: reviewModeSchema,
|
|
1292
1186
|
expectedRelease: identifier.nullable().optional(),
|
|
1293
|
-
settingRenames:
|
|
1187
|
+
settingRenames: z14.record(z14.string(), z14.string()).optional()
|
|
1294
1188
|
}).strict();
|
|
1295
|
-
var batchReleaseSchema =
|
|
1296
|
-
var questSettingsInputSchema =
|
|
1189
|
+
var batchReleaseSchema = z14.object({ releases: z14.array(releaseSchema).min(1).max(50) }).strict();
|
|
1190
|
+
var questSettingsInputSchema = z14.object({
|
|
1297
1191
|
quest: identifier,
|
|
1298
1192
|
expectedRelease: identifier,
|
|
1299
1193
|
set: settingsValuesSchema,
|
|
1300
|
-
reset:
|
|
1194
|
+
reset: z14.array(z14.string())
|
|
1301
1195
|
}).strict();
|
|
1302
1196
|
var storedReleaseSchema = questDescriptionSchema.extend({
|
|
1303
1197
|
key: identifier.optional(),
|
|
1304
|
-
code:
|
|
1198
|
+
code: z14.string(),
|
|
1305
1199
|
provider: storedReviewModeSchema,
|
|
1306
1200
|
id: identifier,
|
|
1307
|
-
createdAt:
|
|
1308
|
-
legacy:
|
|
1309
|
-
origin:
|
|
1310
|
-
lifecycle:
|
|
1311
|
-
configuration:
|
|
1201
|
+
createdAt: z14.number(),
|
|
1202
|
+
legacy: z14.boolean().default(false),
|
|
1203
|
+
origin: z14.object({ typeVersion: identifier }).strict().optional(),
|
|
1204
|
+
lifecycle: z14.enum(["active", "paused", "archived"]).default("active"),
|
|
1205
|
+
configuration: z14.object({
|
|
1312
1206
|
defaults: settingsValuesSchema,
|
|
1313
1207
|
overrides: settingsValuesSchema,
|
|
1314
|
-
preserved:
|
|
1208
|
+
preserved: z14.array(z14.string())
|
|
1315
1209
|
}).strict().optional()
|
|
1316
1210
|
});
|
|
1317
|
-
var legacyReleaseSchema =
|
|
1211
|
+
var legacyReleaseSchema = z14.object({
|
|
1318
1212
|
quest: identifier,
|
|
1319
|
-
title:
|
|
1320
|
-
criteria:
|
|
1321
|
-
humanReview:
|
|
1213
|
+
title: z14.string(),
|
|
1214
|
+
criteria: z14.string(),
|
|
1215
|
+
humanReview: z14.boolean(),
|
|
1322
1216
|
rewards: rewardBundleSchema,
|
|
1323
|
-
code:
|
|
1217
|
+
code: z14.string(),
|
|
1324
1218
|
provider: storedReviewModeSchema,
|
|
1325
1219
|
id: identifier,
|
|
1326
|
-
createdAt:
|
|
1220
|
+
createdAt: z14.number()
|
|
1327
1221
|
}).transform((r) => {
|
|
1328
1222
|
const { criteria, ...stored } = r;
|
|
1329
1223
|
return storedReleaseSchema.parse({
|
|
@@ -1335,15 +1229,15 @@ var legacyReleaseSchema = z13.object({
|
|
|
1335
1229
|
legacy: true
|
|
1336
1230
|
});
|
|
1337
1231
|
});
|
|
1338
|
-
var publishedReleaseSchema =
|
|
1232
|
+
var publishedReleaseSchema = z14.union([
|
|
1339
1233
|
storedReleaseSchema,
|
|
1340
1234
|
legacyReleaseSchema
|
|
1341
1235
|
]);
|
|
1342
|
-
var templateSchema =
|
|
1343
|
-
code:
|
|
1236
|
+
var templateSchema = z14.object({
|
|
1237
|
+
code: z14.string(),
|
|
1344
1238
|
definition: questDescriptionSchema
|
|
1345
1239
|
});
|
|
1346
|
-
var quizAnswersSchema =
|
|
1240
|
+
var quizAnswersSchema = z14.record(identifier, identifier).refine(
|
|
1347
1241
|
(answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
|
|
1348
1242
|
"Provide between 1 and 50 answers"
|
|
1349
1243
|
).transform(
|
|
@@ -1351,33 +1245,33 @@ var quizAnswersSchema = z13.record(identifier, identifier).refine(
|
|
|
1351
1245
|
Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
|
|
1352
1246
|
)
|
|
1353
1247
|
);
|
|
1354
|
-
var quizEvidenceSchema =
|
|
1355
|
-
kind:
|
|
1248
|
+
var quizEvidenceSchema = z14.object({
|
|
1249
|
+
kind: z14.literal("quiz"),
|
|
1356
1250
|
release: identifier.optional(),
|
|
1357
1251
|
answers: quizAnswersSchema
|
|
1358
1252
|
}).strict();
|
|
1359
|
-
var submissionEvidenceSchema =
|
|
1253
|
+
var submissionEvidenceSchema = z14.union([
|
|
1360
1254
|
quizEvidenceSchema,
|
|
1361
1255
|
textEvidenceSchema,
|
|
1362
1256
|
urlEvidenceSchema
|
|
1363
1257
|
]);
|
|
1364
|
-
var submitSchema =
|
|
1258
|
+
var submitSchema = z14.object({
|
|
1365
1259
|
actionId: identifier,
|
|
1366
1260
|
quest: identifier,
|
|
1367
1261
|
member: identifier,
|
|
1368
1262
|
evidence: identifier.optional(),
|
|
1369
1263
|
input: submissionEvidenceSchema.optional(),
|
|
1370
1264
|
release: identifier.optional(),
|
|
1371
|
-
faultAfterReview:
|
|
1265
|
+
faultAfterReview: z14.boolean().optional()
|
|
1372
1266
|
}).strict();
|
|
1373
|
-
var attemptSchema =
|
|
1267
|
+
var attemptSchema = z14.object({
|
|
1374
1268
|
id: identifier,
|
|
1375
1269
|
release: identifier,
|
|
1376
1270
|
quest: identifier,
|
|
1377
1271
|
member: identifier,
|
|
1378
1272
|
evidence: identifier.nullable(),
|
|
1379
1273
|
input: submissionEvidenceSchema.optional(),
|
|
1380
|
-
status:
|
|
1274
|
+
status: z14.enum([
|
|
1381
1275
|
"queued",
|
|
1382
1276
|
"evaluating",
|
|
1383
1277
|
"accepted",
|
|
@@ -1386,70 +1280,75 @@ var attemptSchema = z13.object({
|
|
|
1386
1280
|
"needs-review",
|
|
1387
1281
|
"failed"
|
|
1388
1282
|
]),
|
|
1389
|
-
reason:
|
|
1390
|
-
retries:
|
|
1391
|
-
generation:
|
|
1392
|
-
completion:
|
|
1283
|
+
reason: z14.string().nullable(),
|
|
1284
|
+
retries: z14.number(),
|
|
1285
|
+
generation: z14.number(),
|
|
1286
|
+
completion: z14.string().nullable(),
|
|
1393
1287
|
reviewRewards: rewardBundleSchema.nullable().default(null),
|
|
1394
|
-
|
|
1288
|
+
/**
|
|
1289
|
+
* The evaluator asked for human review of a quest with review off, so Domino rejected the attempt
|
|
1290
|
+
* with the evaluator's reason. Only set on a rejected attempt.
|
|
1291
|
+
*/
|
|
1292
|
+
requestedReview: z14.boolean().default(false),
|
|
1293
|
+
createdAt: z14.number()
|
|
1395
1294
|
});
|
|
1396
|
-
var eventSchema =
|
|
1397
|
-
id:
|
|
1398
|
-
attempt:
|
|
1399
|
-
kind:
|
|
1400
|
-
detail:
|
|
1401
|
-
actor:
|
|
1402
|
-
at:
|
|
1295
|
+
var eventSchema = z14.object({
|
|
1296
|
+
id: z14.number(),
|
|
1297
|
+
attempt: z14.string().nullable(),
|
|
1298
|
+
kind: z14.string(),
|
|
1299
|
+
detail: z14.string(),
|
|
1300
|
+
actor: z14.string().nullable().default(null),
|
|
1301
|
+
at: z14.number()
|
|
1403
1302
|
});
|
|
1404
|
-
var pickupSelectionSchema =
|
|
1303
|
+
var pickupSelectionSchema = z14.object({
|
|
1405
1304
|
item: identifier,
|
|
1406
|
-
revision:
|
|
1305
|
+
revision: z14.number().int().nonnegative()
|
|
1407
1306
|
}).strict();
|
|
1408
|
-
var pickupAllocationSchema =
|
|
1307
|
+
var pickupAllocationSchema = z14.object({
|
|
1409
1308
|
item: identifier,
|
|
1410
|
-
label:
|
|
1309
|
+
label: z14.string().min(1).max(80)
|
|
1411
1310
|
}).strict();
|
|
1412
|
-
var pickupPolicySchema =
|
|
1413
|
-
|
|
1414
|
-
|
|
1415
|
-
kind:
|
|
1416
|
-
tiers:
|
|
1417
|
-
|
|
1311
|
+
var pickupPolicySchema = z14.discriminatedUnion("kind", [
|
|
1312
|
+
z14.object({ kind: z14.literal("untracked") }).strict(),
|
|
1313
|
+
z14.object({
|
|
1314
|
+
kind: z14.literal("at-pickup"),
|
|
1315
|
+
tiers: z14.array(
|
|
1316
|
+
z14.object({
|
|
1418
1317
|
tier: identifier,
|
|
1419
|
-
variants:
|
|
1318
|
+
variants: z14.array(pickupAllocationSchema).min(1).max(100)
|
|
1420
1319
|
}).strict()
|
|
1421
1320
|
).min(1).max(100)
|
|
1422
1321
|
}).strict()
|
|
1423
1322
|
]);
|
|
1424
|
-
var pickupCatalogSchema =
|
|
1323
|
+
var pickupCatalogSchema = z14.object({
|
|
1425
1324
|
reward: tieredRewardDefinitionSchema,
|
|
1426
|
-
revision:
|
|
1325
|
+
revision: z14.number().int().nonnegative(),
|
|
1427
1326
|
policy: pickupPolicySchema
|
|
1428
1327
|
});
|
|
1429
|
-
var pickupAvailabilitySchema =
|
|
1430
|
-
|
|
1431
|
-
|
|
1432
|
-
kind:
|
|
1433
|
-
revision:
|
|
1434
|
-
variants:
|
|
1328
|
+
var pickupAvailabilitySchema = z14.discriminatedUnion("kind", [
|
|
1329
|
+
z14.object({ kind: z14.literal("untracked") }).strict(),
|
|
1330
|
+
z14.object({
|
|
1331
|
+
kind: z14.literal("at-pickup"),
|
|
1332
|
+
revision: z14.number().int().nonnegative(),
|
|
1333
|
+
variants: z14.array(
|
|
1435
1334
|
pickupAllocationSchema.extend({
|
|
1436
|
-
available:
|
|
1335
|
+
available: z14.number().int().nonnegative()
|
|
1437
1336
|
})
|
|
1438
1337
|
)
|
|
1439
1338
|
}).strict()
|
|
1440
1339
|
]);
|
|
1441
|
-
var configurePickupSchema =
|
|
1340
|
+
var configurePickupSchema = z14.object({
|
|
1442
1341
|
reward: identifier,
|
|
1443
|
-
revision:
|
|
1342
|
+
revision: z14.number().int().nonnegative(),
|
|
1444
1343
|
actionId: identifier,
|
|
1445
|
-
policy:
|
|
1446
|
-
|
|
1447
|
-
|
|
1448
|
-
kind:
|
|
1449
|
-
tiers:
|
|
1450
|
-
|
|
1344
|
+
policy: z14.discriminatedUnion("kind", [
|
|
1345
|
+
z14.object({ kind: z14.literal("untracked") }).strict(),
|
|
1346
|
+
z14.object({
|
|
1347
|
+
kind: z14.literal("at-pickup"),
|
|
1348
|
+
tiers: z14.array(
|
|
1349
|
+
z14.object({
|
|
1451
1350
|
tier: identifier,
|
|
1452
|
-
variants:
|
|
1351
|
+
variants: z14.array(
|
|
1453
1352
|
pickupAllocationSchema.extend({
|
|
1454
1353
|
item: identifier.optional()
|
|
1455
1354
|
})
|
|
@@ -1465,164 +1364,164 @@ var entitlementBase = {
|
|
|
1465
1364
|
reward: tieredRewardDefinitionSchema,
|
|
1466
1365
|
earnedTier: identifier,
|
|
1467
1366
|
tier: identifier,
|
|
1468
|
-
revision:
|
|
1367
|
+
revision: z14.number().int().positive()
|
|
1469
1368
|
};
|
|
1470
|
-
var entitlementSchema =
|
|
1471
|
-
|
|
1472
|
-
|
|
1369
|
+
var entitlementSchema = z14.discriminatedUnion("status", [
|
|
1370
|
+
z14.object({ ...entitlementBase, status: z14.literal("available") }).strict(),
|
|
1371
|
+
z14.object({
|
|
1473
1372
|
...entitlementBase,
|
|
1474
|
-
status:
|
|
1373
|
+
status: z14.literal("handing-over"),
|
|
1475
1374
|
handover: identifier,
|
|
1476
|
-
startedAt:
|
|
1375
|
+
startedAt: z14.number(),
|
|
1477
1376
|
allocation: pickupAllocationSchema.optional()
|
|
1478
1377
|
}).strict(),
|
|
1479
|
-
|
|
1378
|
+
z14.object({
|
|
1480
1379
|
...entitlementBase,
|
|
1481
|
-
status:
|
|
1380
|
+
status: z14.literal("collected"),
|
|
1482
1381
|
handover: identifier,
|
|
1483
|
-
startedAt:
|
|
1382
|
+
startedAt: z14.number(),
|
|
1484
1383
|
allocation: pickupAllocationSchema.optional(),
|
|
1485
|
-
collectedAt:
|
|
1384
|
+
collectedAt: z14.number()
|
|
1486
1385
|
}).strict()
|
|
1487
1386
|
]);
|
|
1488
|
-
var beginHandoverSchema =
|
|
1387
|
+
var beginHandoverSchema = z14.object({
|
|
1489
1388
|
actionId: identifier,
|
|
1490
|
-
revision:
|
|
1389
|
+
revision: z14.number().int().positive(),
|
|
1491
1390
|
selection: pickupSelectionSchema.optional()
|
|
1492
1391
|
}).strict();
|
|
1493
|
-
var confirmHandoverSchema =
|
|
1494
|
-
var completionRecordSchema =
|
|
1495
|
-
key:
|
|
1392
|
+
var confirmHandoverSchema = z14.object({ actionId: identifier, handover: identifier }).strict();
|
|
1393
|
+
var completionRecordSchema = z14.object({
|
|
1394
|
+
key: z14.string().default("once"),
|
|
1496
1395
|
id: identifier,
|
|
1497
1396
|
quest: identifier,
|
|
1498
1397
|
member: identifier
|
|
1499
1398
|
});
|
|
1500
|
-
var questAvailabilitySchema =
|
|
1501
|
-
|
|
1502
|
-
kind:
|
|
1503
|
-
input:
|
|
1399
|
+
var questAvailabilitySchema = z14.discriminatedUnion("kind", [
|
|
1400
|
+
z14.object({
|
|
1401
|
+
kind: z14.literal("available"),
|
|
1402
|
+
input: z14.enum(["photo", "quiz", "none", "text", "url"])
|
|
1504
1403
|
}).strict(),
|
|
1505
|
-
|
|
1506
|
-
|
|
1507
|
-
kind:
|
|
1508
|
-
missing:
|
|
1404
|
+
z14.object({ kind: z14.literal("completed") }).strict(),
|
|
1405
|
+
z14.object({
|
|
1406
|
+
kind: z14.literal("locked"),
|
|
1407
|
+
missing: z14.array(z14.object({ quest: identifier, title: z14.string() })).min(1)
|
|
1509
1408
|
}).strict(),
|
|
1510
|
-
|
|
1511
|
-
|
|
1512
|
-
kind:
|
|
1409
|
+
z14.object({ kind: z14.literal("staff-required") }).strict(),
|
|
1410
|
+
z14.object({
|
|
1411
|
+
kind: z14.literal("automatic"),
|
|
1513
1412
|
observation: observationTriggerSchema.optional()
|
|
1514
1413
|
}).strict(),
|
|
1515
|
-
|
|
1516
|
-
|
|
1517
|
-
|
|
1414
|
+
z14.object({ kind: z14.literal("checking"), attempt: identifier }).strict(),
|
|
1415
|
+
z14.object({ kind: z14.literal("needs-review"), attempt: identifier }).strict(),
|
|
1416
|
+
z14.object({ kind: z14.literal("retryable"), attempt: identifier }).strict()
|
|
1518
1417
|
]);
|
|
1519
|
-
var memberProgressSchema =
|
|
1418
|
+
var memberProgressSchema = z14.object({
|
|
1520
1419
|
member: identifier,
|
|
1521
|
-
quests:
|
|
1522
|
-
|
|
1420
|
+
quests: z14.array(
|
|
1421
|
+
z14.object({
|
|
1523
1422
|
quest: identifier,
|
|
1524
1423
|
key: identifier.optional(),
|
|
1525
1424
|
release: identifier.optional(),
|
|
1526
|
-
title:
|
|
1425
|
+
title: z14.string(),
|
|
1527
1426
|
presentation: questPresentationSchema.default({}),
|
|
1528
|
-
connections:
|
|
1427
|
+
connections: z14.array(authProviderSchema).default([]),
|
|
1529
1428
|
trigger: triggerSchema,
|
|
1530
1429
|
availability: questAvailabilitySchema,
|
|
1531
|
-
completed:
|
|
1430
|
+
completed: z14.boolean(),
|
|
1532
1431
|
completion: completionPolicySchema.default({ kind: "once" }),
|
|
1533
1432
|
streak: streakProgressSchema.nullable().optional(),
|
|
1534
|
-
completionCount:
|
|
1535
|
-
visibility:
|
|
1536
|
-
missing:
|
|
1433
|
+
completionCount: z14.number().int().nonnegative().default(0),
|
|
1434
|
+
visibility: z14.enum(["visible", "hidden"]).default("visible"),
|
|
1435
|
+
missing: z14.array(z14.object({ quest: identifier, title: z14.string() })),
|
|
1537
1436
|
attempt: attemptSchema.nullable()
|
|
1538
1437
|
})
|
|
1539
1438
|
),
|
|
1540
|
-
entitlements:
|
|
1439
|
+
entitlements: z14.array(entitlementSchema)
|
|
1541
1440
|
});
|
|
1542
|
-
var snapshotSchema =
|
|
1543
|
-
releases:
|
|
1544
|
-
completions:
|
|
1545
|
-
entitlements:
|
|
1546
|
-
attempts:
|
|
1547
|
-
balances:
|
|
1548
|
-
|
|
1549
|
-
member:
|
|
1550
|
-
balance:
|
|
1551
|
-
earned:
|
|
1552
|
-
held:
|
|
1553
|
-
available:
|
|
1441
|
+
var snapshotSchema = z14.object({
|
|
1442
|
+
releases: z14.array(publishedReleaseSchema),
|
|
1443
|
+
completions: z14.array(completionRecordSchema),
|
|
1444
|
+
entitlements: z14.array(entitlementSchema),
|
|
1445
|
+
attempts: z14.array(attemptSchema),
|
|
1446
|
+
balances: z14.array(
|
|
1447
|
+
z14.object({
|
|
1448
|
+
member: z14.string(),
|
|
1449
|
+
balance: z14.string(),
|
|
1450
|
+
earned: z14.number(),
|
|
1451
|
+
held: z14.number(),
|
|
1452
|
+
available: z14.number()
|
|
1554
1453
|
})
|
|
1555
1454
|
),
|
|
1556
|
-
events:
|
|
1455
|
+
events: z14.array(eventSchema)
|
|
1557
1456
|
});
|
|
1558
|
-
var evidenceSchema =
|
|
1457
|
+
var evidenceSchema = z14.object({
|
|
1559
1458
|
id: identifier,
|
|
1560
1459
|
member: identifier,
|
|
1561
|
-
type:
|
|
1562
|
-
size:
|
|
1460
|
+
type: z14.enum(["image/jpeg", "image/png"]),
|
|
1461
|
+
size: z14.number()
|
|
1563
1462
|
});
|
|
1564
|
-
var errorSchema =
|
|
1565
|
-
error:
|
|
1566
|
-
code:
|
|
1567
|
-
missing:
|
|
1463
|
+
var errorSchema = z14.object({
|
|
1464
|
+
error: z14.string(),
|
|
1465
|
+
code: z14.enum(["stale-quiz", "quest-updated", "invalid-submission"]).optional(),
|
|
1466
|
+
missing: z14.array(z14.object({ quest: identifier, title: z14.string() })).optional()
|
|
1568
1467
|
});
|
|
1569
|
-
var staffDecisionSchema =
|
|
1468
|
+
var staffDecisionSchema = z14.object({
|
|
1570
1469
|
actionId: identifier,
|
|
1571
|
-
generation:
|
|
1572
|
-
decision:
|
|
1573
|
-
reason:
|
|
1470
|
+
generation: z14.number().int().nonnegative(),
|
|
1471
|
+
decision: z14.enum(["accept", "reject"]),
|
|
1472
|
+
reason: z14.string().trim().min(1).max(2e3)
|
|
1574
1473
|
}).strict();
|
|
1575
|
-
var stockSchema =
|
|
1576
|
-
var reservationSchema =
|
|
1474
|
+
var stockSchema = z14.object({ item: identifier, quantity: z14.number().int().min(0).max(1e4) }).strict();
|
|
1475
|
+
var reservationSchema = z14.object({
|
|
1577
1476
|
actionId: identifier,
|
|
1578
1477
|
member: identifier,
|
|
1579
1478
|
item: identifier,
|
|
1580
1479
|
balance: identifier,
|
|
1581
|
-
price:
|
|
1480
|
+
price: z14.number().int().positive().max(1e4)
|
|
1582
1481
|
}).strict();
|
|
1583
1482
|
var pageOptions = {
|
|
1584
|
-
limit:
|
|
1585
|
-
cursor:
|
|
1483
|
+
limit: z14.number().int().min(1).max(100).default(25),
|
|
1484
|
+
cursor: z14.string().min(1).max(4096).optional()
|
|
1586
1485
|
};
|
|
1587
|
-
var reviewListSchema =
|
|
1486
|
+
var reviewListSchema = z14.object({
|
|
1588
1487
|
...pageOptions,
|
|
1589
1488
|
member: identifier.optional(),
|
|
1590
1489
|
quest: identifier.optional()
|
|
1591
1490
|
}).strict();
|
|
1592
|
-
var memberListSchema =
|
|
1491
|
+
var memberListSchema = z14.object({
|
|
1593
1492
|
...pageOptions,
|
|
1594
1493
|
prefix: identifier.optional()
|
|
1595
1494
|
}).strict();
|
|
1596
|
-
var reviewItemSchema =
|
|
1495
|
+
var reviewItemSchema = z14.object({
|
|
1597
1496
|
attempt: attemptSchema,
|
|
1598
|
-
title:
|
|
1599
|
-
checks:
|
|
1600
|
-
|
|
1497
|
+
title: z14.string(),
|
|
1498
|
+
checks: z14.array(
|
|
1499
|
+
z14.object({ criteria: z14.string(), result: photoResultSchema })
|
|
1601
1500
|
)
|
|
1602
1501
|
});
|
|
1603
|
-
var reviewPageSchema =
|
|
1604
|
-
items:
|
|
1605
|
-
nextCursor:
|
|
1502
|
+
var reviewPageSchema = z14.object({
|
|
1503
|
+
items: z14.array(reviewItemSchema).max(100),
|
|
1504
|
+
nextCursor: z14.string().nullable()
|
|
1606
1505
|
});
|
|
1607
|
-
var memberPageSchema =
|
|
1608
|
-
items:
|
|
1609
|
-
nextCursor:
|
|
1506
|
+
var memberPageSchema = z14.object({
|
|
1507
|
+
items: z14.array(z14.object({ member: identifier })).max(100),
|
|
1508
|
+
nextCursor: z14.string().nullable()
|
|
1610
1509
|
});
|
|
1611
|
-
var createStockItemSchema =
|
|
1612
|
-
var stockItemSchema =
|
|
1613
|
-
var contentPerformanceSnapshotSchema =
|
|
1510
|
+
var createStockItemSchema = z14.object({ actionId: identifier, name: z14.string().trim().min(1).max(80) }).strict();
|
|
1511
|
+
var stockItemSchema = z14.object({ id: identifier, name: z14.string() });
|
|
1512
|
+
var contentPerformanceSnapshotSchema = z14.strictObject({
|
|
1614
1513
|
contentAttempt: identifier,
|
|
1615
1514
|
observation: identifier,
|
|
1616
|
-
observedAt:
|
|
1515
|
+
observedAt: z14.number().int().safe().nonnegative(),
|
|
1617
1516
|
metrics: contentMetricsSchema,
|
|
1618
1517
|
rewards: rewardBundleSchema
|
|
1619
1518
|
});
|
|
1620
1519
|
var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
|
|
1621
|
-
content:
|
|
1520
|
+
content: z14.string().min(1).max(256)
|
|
1622
1521
|
});
|
|
1623
|
-
var contentPerformancePageSchema =
|
|
1624
|
-
current:
|
|
1625
|
-
state:
|
|
1522
|
+
var contentPerformancePageSchema = z14.strictObject({
|
|
1523
|
+
current: z14.strictObject({
|
|
1524
|
+
state: z14.enum([
|
|
1626
1525
|
"content-pending",
|
|
1627
1526
|
"content-unqualified",
|
|
1628
1527
|
"waiting",
|
|
@@ -1633,19 +1532,19 @@ var contentPerformancePageSchema = z13.strictObject({
|
|
|
1633
1532
|
"failed",
|
|
1634
1533
|
"superseded"
|
|
1635
1534
|
]),
|
|
1636
|
-
reason:
|
|
1535
|
+
reason: z14.string().nullable(),
|
|
1637
1536
|
contentAttempt: identifier,
|
|
1638
1537
|
attempt: identifier.nullable(),
|
|
1639
1538
|
reward: contentQualificationSchema.shape.reward
|
|
1640
1539
|
}),
|
|
1641
|
-
items:
|
|
1642
|
-
|
|
1540
|
+
items: z14.array(
|
|
1541
|
+
z14.strictObject({
|
|
1643
1542
|
attempt: identifier,
|
|
1644
1543
|
contentAttempt: identifier,
|
|
1645
1544
|
observation: identifier,
|
|
1646
|
-
observedAt:
|
|
1545
|
+
observedAt: z14.number(),
|
|
1647
1546
|
metrics: contentMetricsSchema,
|
|
1648
|
-
state:
|
|
1547
|
+
state: z14.enum([
|
|
1649
1548
|
"pending",
|
|
1650
1549
|
"qualified",
|
|
1651
1550
|
"unqualified",
|
|
@@ -1653,13 +1552,18 @@ var contentPerformancePageSchema = z13.strictObject({
|
|
|
1653
1552
|
"failed",
|
|
1654
1553
|
"superseded"
|
|
1655
1554
|
]),
|
|
1656
|
-
reason:
|
|
1555
|
+
reason: z14.string().nullable()
|
|
1657
1556
|
})
|
|
1658
1557
|
),
|
|
1659
|
-
next:
|
|
1558
|
+
next: z14.number().int().positive().safe().nullable()
|
|
1660
1559
|
});
|
|
1661
1560
|
|
|
1662
1561
|
export {
|
|
1562
|
+
authProviderSchema,
|
|
1563
|
+
accountConnectionSchema,
|
|
1564
|
+
discordMemberInputSchema,
|
|
1565
|
+
discordMessageInputSchema,
|
|
1566
|
+
discordMemberSchema,
|
|
1663
1567
|
identifier,
|
|
1664
1568
|
xTweetSchema,
|
|
1665
1569
|
xContentBodySchema,
|
|
@@ -1674,11 +1578,8 @@ export {
|
|
|
1674
1578
|
customSourceSchema,
|
|
1675
1579
|
trackerSourceSchema,
|
|
1676
1580
|
sourceIdentities,
|
|
1677
|
-
x,
|
|
1678
|
-
customSource,
|
|
1679
1581
|
trackerDefinitionSchema,
|
|
1680
1582
|
trackerArtifactSchema,
|
|
1681
|
-
defineTracker,
|
|
1682
1583
|
publishedTrackerSchema,
|
|
1683
1584
|
trackerStatusSchema,
|
|
1684
1585
|
trackerControlSchema,
|
|
@@ -1699,16 +1600,13 @@ export {
|
|
|
1699
1600
|
trackerPreviewInputSchema,
|
|
1700
1601
|
trackerPreviewSchema,
|
|
1701
1602
|
contentPolicySchema,
|
|
1702
|
-
content,
|
|
1703
1603
|
admittedContentSchema,
|
|
1704
|
-
perContent,
|
|
1705
1604
|
contentEnrollmentInputSchema,
|
|
1706
1605
|
contentEnrollmentSchema,
|
|
1707
1606
|
contentReleaseInputSchema,
|
|
1708
1607
|
contentAdmissionSchema,
|
|
1709
1608
|
contentAdmissionQuerySchema,
|
|
1710
1609
|
contentAdmissionPageSchema,
|
|
1711
|
-
isContentParticipantRoute,
|
|
1712
1610
|
contentQualificationDecisionSchema,
|
|
1713
1611
|
contentQualificationQuerySchema,
|
|
1714
1612
|
contentQualificationSchema,
|
|
@@ -1718,7 +1616,6 @@ export {
|
|
|
1718
1616
|
contentPerformancePolicySchema,
|
|
1719
1617
|
communityTimeZoneSchema,
|
|
1720
1618
|
streakPolicySchema,
|
|
1721
|
-
streak,
|
|
1722
1619
|
streakProgressSchema,
|
|
1723
1620
|
trackerTriggerModeSchema,
|
|
1724
1621
|
defaultTriggerMode,
|
|
@@ -1742,11 +1639,6 @@ export {
|
|
|
1742
1639
|
integrationProviderSchema,
|
|
1743
1640
|
discordServerSchema,
|
|
1744
1641
|
projectIntegrationSchema,
|
|
1745
|
-
authProviderSchema,
|
|
1746
|
-
accountConnectionSchema,
|
|
1747
|
-
discordMemberInputSchema,
|
|
1748
|
-
discordMessageInputSchema,
|
|
1749
|
-
discordMemberSchema,
|
|
1750
1642
|
textOptionsSchema,
|
|
1751
1643
|
urlOptionsSchema,
|
|
1752
1644
|
textEvidenceSchema,
|
|
@@ -1761,12 +1653,11 @@ export {
|
|
|
1761
1653
|
resourceSourceSchema,
|
|
1762
1654
|
resourceRequestSchema,
|
|
1763
1655
|
resourceOptionsSchema,
|
|
1764
|
-
|
|
1765
|
-
|
|
1656
|
+
settingInstant,
|
|
1657
|
+
settingResourceId,
|
|
1766
1658
|
settingFieldSchema,
|
|
1767
1659
|
settingsFieldsSchema,
|
|
1768
1660
|
settingsValuesSchema,
|
|
1769
|
-
settings,
|
|
1770
1661
|
parseSettings,
|
|
1771
1662
|
missingResourceSettings,
|
|
1772
1663
|
compatibleSettingKinds,
|