@domino-sdk/relay 1.0.0-next.6 → 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 +316 -14
- package/dist/authoring.js +177 -23
- package/dist/avatar.d.ts +29 -0
- package/dist/avatar.js +21 -0
- package/dist/browser.d.ts +168 -165
- package/dist/browser.js +6 -6
- package/dist/catalog-C09gnPYT.d.ts +3948 -0
- package/dist/chunk-7HSTFBMO.js +24 -0
- package/dist/{chunk-5IIWKDFX.js → chunk-ADSP377G.js} +1 -1
- package/dist/{chunk-RTHN22KO.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-BRESOTKV.js → chunk-UW6R2QGT.js} +604 -723
- package/dist/chunk-V7UKZLHA.js +35 -0
- package/dist/{chunk-ERBVT7GE.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 -13132
- 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 +37 -34
- package/dist/react/index.js +7 -13
- package/dist/schema-DCapSPHz.d.ts +3396 -0
- package/dist/schema.d.ts +3194 -2372
- 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-XEQDW7FM.js +0 -373
- package/dist/chunk-ZKJBCQNI.js +0 -624
- 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,48 +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
|
-
kind:
|
|
1223
|
-
reason:
|
|
1110
|
+
z14.object({
|
|
1111
|
+
kind: z14.literal("reject"),
|
|
1112
|
+
reason: z14.string().min(1).max(2e3),
|
|
1224
1113
|
/** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
|
|
1225
|
-
requestedReview:
|
|
1114
|
+
requestedReview: z14.literal(true).optional()
|
|
1226
1115
|
}).strict(),
|
|
1227
|
-
|
|
1228
|
-
kind:
|
|
1229
|
-
reason:
|
|
1230
|
-
rewards:
|
|
1116
|
+
z14.object({
|
|
1117
|
+
kind: z14.literal("review"),
|
|
1118
|
+
reason: z14.string().min(1).max(2e3),
|
|
1119
|
+
rewards: z14.array(rewardSchema).max(10).optional(),
|
|
1231
1120
|
completionKey: completionKeySchema.optional()
|
|
1232
1121
|
}).strict()
|
|
1233
1122
|
]);
|
|
1234
|
-
var reviewModeSchema =
|
|
1235
|
-
var storedReviewModeSchema =
|
|
1123
|
+
var reviewModeSchema = z14.enum(["workers-ai"]);
|
|
1124
|
+
var storedReviewModeSchema = z14.enum([
|
|
1236
1125
|
"fixture-pass",
|
|
1237
1126
|
"fixture-fail",
|
|
1238
1127
|
"fixture-unclear",
|
|
1239
1128
|
"fixture-error",
|
|
1240
1129
|
"workers-ai"
|
|
1241
1130
|
]);
|
|
1242
|
-
var rewardBundleSchema =
|
|
1131
|
+
var rewardBundleSchema = z14.array(rewardSchema).max(10).refine(
|
|
1243
1132
|
(rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
|
|
1244
1133
|
"Use one entry per balance or shared reward"
|
|
1245
1134
|
);
|
|
1246
|
-
var mediaUrlSchema =
|
|
1135
|
+
var mediaUrlSchema = z14.string().max(2e3).refine((value) => {
|
|
1247
1136
|
if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
|
|
1248
1137
|
return true;
|
|
1249
1138
|
}
|
|
@@ -1253,82 +1142,82 @@ var mediaUrlSchema = z13.string().max(2e3).refine((value) => {
|
|
|
1253
1142
|
return false;
|
|
1254
1143
|
}
|
|
1255
1144
|
}, "Use an HTTPS URL or a same-site path beginning with /");
|
|
1256
|
-
var questPresentationSchema =
|
|
1145
|
+
var questPresentationSchema = z14.object({
|
|
1257
1146
|
quiz: quizQuestionsSchema.optional(),
|
|
1258
|
-
instructions:
|
|
1259
|
-
video:
|
|
1147
|
+
instructions: z14.string().max(4e3).optional(),
|
|
1148
|
+
video: z14.object({
|
|
1260
1149
|
url: mediaUrlSchema,
|
|
1261
1150
|
poster: mediaUrlSchema.optional(),
|
|
1262
|
-
captions:
|
|
1151
|
+
captions: z14.object({
|
|
1263
1152
|
url: mediaUrlSchema,
|
|
1264
|
-
language:
|
|
1265
|
-
label:
|
|
1153
|
+
language: z14.string().min(2).max(20),
|
|
1154
|
+
label: z14.string().min(1).max(80)
|
|
1266
1155
|
}).strict().optional()
|
|
1267
1156
|
}).strict().optional()
|
|
1268
1157
|
}).strict();
|
|
1269
|
-
var questProfileSchema =
|
|
1270
|
-
var questDescriptionSchema =
|
|
1158
|
+
var questProfileSchema = z14.object({ visible: z14.boolean() }).strict();
|
|
1159
|
+
var questDescriptionSchema = z14.object({
|
|
1271
1160
|
quest: identifier,
|
|
1272
|
-
runtimeVersion:
|
|
1273
|
-
title:
|
|
1161
|
+
runtimeVersion: z14.union([z14.literal(1), z14.literal(2)]).default(1),
|
|
1162
|
+
title: z14.string().min(1).max(120),
|
|
1274
1163
|
presentation: questPresentationSchema.default({}),
|
|
1275
|
-
integrations:
|
|
1164
|
+
integrations: z14.array(integrationProviderSchema).max(10).default([]),
|
|
1276
1165
|
fields: settingsFieldsSchema,
|
|
1277
1166
|
values: settingsValuesSchema,
|
|
1278
1167
|
rewards: rewardBundleSchema,
|
|
1279
|
-
humanReview:
|
|
1168
|
+
humanReview: z14.boolean(),
|
|
1280
1169
|
trigger: triggerSchema,
|
|
1281
1170
|
performance: contentPerformancePolicySchema.optional(),
|
|
1282
|
-
requires:
|
|
1171
|
+
requires: z14.array(prerequisiteSchema).max(30).default([]),
|
|
1283
1172
|
completion: completionPolicySchema,
|
|
1284
|
-
visibility:
|
|
1173
|
+
visibility: z14.enum(["visible", "hidden"]).default("visible"),
|
|
1285
1174
|
/**
|
|
1286
1175
|
* Whether completions show on participant profiles (`/v1/profiles/:id/completions`). Absent
|
|
1287
1176
|
* is hidden. Optional, not defaulted: releases carry the key only when the author sets it, so
|
|
1288
1177
|
* clients and pods that predate it (strict release schemas) still read every other release.
|
|
1289
1178
|
*/
|
|
1290
1179
|
profile: questProfileSchema.optional(),
|
|
1291
|
-
budgets:
|
|
1180
|
+
budgets: z14.array(budgetSchema).max(20).default([])
|
|
1292
1181
|
}).strict();
|
|
1293
|
-
var artifactSchema =
|
|
1182
|
+
var artifactSchema = z14.object({ code: z14.string().min(1).max(1e6) }).strict();
|
|
1294
1183
|
var releaseSchema = artifactSchema.extend({
|
|
1295
1184
|
settings: settingsValuesSchema,
|
|
1296
1185
|
provider: reviewModeSchema,
|
|
1297
1186
|
expectedRelease: identifier.nullable().optional(),
|
|
1298
|
-
settingRenames:
|
|
1187
|
+
settingRenames: z14.record(z14.string(), z14.string()).optional()
|
|
1299
1188
|
}).strict();
|
|
1300
|
-
var batchReleaseSchema =
|
|
1301
|
-
var questSettingsInputSchema =
|
|
1189
|
+
var batchReleaseSchema = z14.object({ releases: z14.array(releaseSchema).min(1).max(50) }).strict();
|
|
1190
|
+
var questSettingsInputSchema = z14.object({
|
|
1302
1191
|
quest: identifier,
|
|
1303
1192
|
expectedRelease: identifier,
|
|
1304
1193
|
set: settingsValuesSchema,
|
|
1305
|
-
reset:
|
|
1194
|
+
reset: z14.array(z14.string())
|
|
1306
1195
|
}).strict();
|
|
1307
1196
|
var storedReleaseSchema = questDescriptionSchema.extend({
|
|
1308
1197
|
key: identifier.optional(),
|
|
1309
|
-
code:
|
|
1198
|
+
code: z14.string(),
|
|
1310
1199
|
provider: storedReviewModeSchema,
|
|
1311
1200
|
id: identifier,
|
|
1312
|
-
createdAt:
|
|
1313
|
-
legacy:
|
|
1314
|
-
origin:
|
|
1315
|
-
lifecycle:
|
|
1316
|
-
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({
|
|
1317
1206
|
defaults: settingsValuesSchema,
|
|
1318
1207
|
overrides: settingsValuesSchema,
|
|
1319
|
-
preserved:
|
|
1208
|
+
preserved: z14.array(z14.string())
|
|
1320
1209
|
}).strict().optional()
|
|
1321
1210
|
});
|
|
1322
|
-
var legacyReleaseSchema =
|
|
1211
|
+
var legacyReleaseSchema = z14.object({
|
|
1323
1212
|
quest: identifier,
|
|
1324
|
-
title:
|
|
1325
|
-
criteria:
|
|
1326
|
-
humanReview:
|
|
1213
|
+
title: z14.string(),
|
|
1214
|
+
criteria: z14.string(),
|
|
1215
|
+
humanReview: z14.boolean(),
|
|
1327
1216
|
rewards: rewardBundleSchema,
|
|
1328
|
-
code:
|
|
1217
|
+
code: z14.string(),
|
|
1329
1218
|
provider: storedReviewModeSchema,
|
|
1330
1219
|
id: identifier,
|
|
1331
|
-
createdAt:
|
|
1220
|
+
createdAt: z14.number()
|
|
1332
1221
|
}).transform((r) => {
|
|
1333
1222
|
const { criteria, ...stored } = r;
|
|
1334
1223
|
return storedReleaseSchema.parse({
|
|
@@ -1340,15 +1229,15 @@ var legacyReleaseSchema = z13.object({
|
|
|
1340
1229
|
legacy: true
|
|
1341
1230
|
});
|
|
1342
1231
|
});
|
|
1343
|
-
var publishedReleaseSchema =
|
|
1232
|
+
var publishedReleaseSchema = z14.union([
|
|
1344
1233
|
storedReleaseSchema,
|
|
1345
1234
|
legacyReleaseSchema
|
|
1346
1235
|
]);
|
|
1347
|
-
var templateSchema =
|
|
1348
|
-
code:
|
|
1236
|
+
var templateSchema = z14.object({
|
|
1237
|
+
code: z14.string(),
|
|
1349
1238
|
definition: questDescriptionSchema
|
|
1350
1239
|
});
|
|
1351
|
-
var quizAnswersSchema =
|
|
1240
|
+
var quizAnswersSchema = z14.record(identifier, identifier).refine(
|
|
1352
1241
|
(answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
|
|
1353
1242
|
"Provide between 1 and 50 answers"
|
|
1354
1243
|
).transform(
|
|
@@ -1356,33 +1245,33 @@ var quizAnswersSchema = z13.record(identifier, identifier).refine(
|
|
|
1356
1245
|
Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
|
|
1357
1246
|
)
|
|
1358
1247
|
);
|
|
1359
|
-
var quizEvidenceSchema =
|
|
1360
|
-
kind:
|
|
1248
|
+
var quizEvidenceSchema = z14.object({
|
|
1249
|
+
kind: z14.literal("quiz"),
|
|
1361
1250
|
release: identifier.optional(),
|
|
1362
1251
|
answers: quizAnswersSchema
|
|
1363
1252
|
}).strict();
|
|
1364
|
-
var submissionEvidenceSchema =
|
|
1253
|
+
var submissionEvidenceSchema = z14.union([
|
|
1365
1254
|
quizEvidenceSchema,
|
|
1366
1255
|
textEvidenceSchema,
|
|
1367
1256
|
urlEvidenceSchema
|
|
1368
1257
|
]);
|
|
1369
|
-
var submitSchema =
|
|
1258
|
+
var submitSchema = z14.object({
|
|
1370
1259
|
actionId: identifier,
|
|
1371
1260
|
quest: identifier,
|
|
1372
1261
|
member: identifier,
|
|
1373
1262
|
evidence: identifier.optional(),
|
|
1374
1263
|
input: submissionEvidenceSchema.optional(),
|
|
1375
1264
|
release: identifier.optional(),
|
|
1376
|
-
faultAfterReview:
|
|
1265
|
+
faultAfterReview: z14.boolean().optional()
|
|
1377
1266
|
}).strict();
|
|
1378
|
-
var attemptSchema =
|
|
1267
|
+
var attemptSchema = z14.object({
|
|
1379
1268
|
id: identifier,
|
|
1380
1269
|
release: identifier,
|
|
1381
1270
|
quest: identifier,
|
|
1382
1271
|
member: identifier,
|
|
1383
1272
|
evidence: identifier.nullable(),
|
|
1384
1273
|
input: submissionEvidenceSchema.optional(),
|
|
1385
|
-
status:
|
|
1274
|
+
status: z14.enum([
|
|
1386
1275
|
"queued",
|
|
1387
1276
|
"evaluating",
|
|
1388
1277
|
"accepted",
|
|
@@ -1391,75 +1280,75 @@ var attemptSchema = z13.object({
|
|
|
1391
1280
|
"needs-review",
|
|
1392
1281
|
"failed"
|
|
1393
1282
|
]),
|
|
1394
|
-
reason:
|
|
1395
|
-
retries:
|
|
1396
|
-
generation:
|
|
1397
|
-
completion:
|
|
1283
|
+
reason: z14.string().nullable(),
|
|
1284
|
+
retries: z14.number(),
|
|
1285
|
+
generation: z14.number(),
|
|
1286
|
+
completion: z14.string().nullable(),
|
|
1398
1287
|
reviewRewards: rewardBundleSchema.nullable().default(null),
|
|
1399
1288
|
/**
|
|
1400
1289
|
* The evaluator asked for human review of a quest with review off, so Domino rejected the attempt
|
|
1401
1290
|
* with the evaluator's reason. Only set on a rejected attempt.
|
|
1402
1291
|
*/
|
|
1403
|
-
requestedReview:
|
|
1404
|
-
createdAt:
|
|
1292
|
+
requestedReview: z14.boolean().default(false),
|
|
1293
|
+
createdAt: z14.number()
|
|
1405
1294
|
});
|
|
1406
|
-
var eventSchema =
|
|
1407
|
-
id:
|
|
1408
|
-
attempt:
|
|
1409
|
-
kind:
|
|
1410
|
-
detail:
|
|
1411
|
-
actor:
|
|
1412
|
-
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()
|
|
1413
1302
|
});
|
|
1414
|
-
var pickupSelectionSchema =
|
|
1303
|
+
var pickupSelectionSchema = z14.object({
|
|
1415
1304
|
item: identifier,
|
|
1416
|
-
revision:
|
|
1305
|
+
revision: z14.number().int().nonnegative()
|
|
1417
1306
|
}).strict();
|
|
1418
|
-
var pickupAllocationSchema =
|
|
1307
|
+
var pickupAllocationSchema = z14.object({
|
|
1419
1308
|
item: identifier,
|
|
1420
|
-
label:
|
|
1309
|
+
label: z14.string().min(1).max(80)
|
|
1421
1310
|
}).strict();
|
|
1422
|
-
var pickupPolicySchema =
|
|
1423
|
-
|
|
1424
|
-
|
|
1425
|
-
kind:
|
|
1426
|
-
tiers:
|
|
1427
|
-
|
|
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({
|
|
1428
1317
|
tier: identifier,
|
|
1429
|
-
variants:
|
|
1318
|
+
variants: z14.array(pickupAllocationSchema).min(1).max(100)
|
|
1430
1319
|
}).strict()
|
|
1431
1320
|
).min(1).max(100)
|
|
1432
1321
|
}).strict()
|
|
1433
1322
|
]);
|
|
1434
|
-
var pickupCatalogSchema =
|
|
1323
|
+
var pickupCatalogSchema = z14.object({
|
|
1435
1324
|
reward: tieredRewardDefinitionSchema,
|
|
1436
|
-
revision:
|
|
1325
|
+
revision: z14.number().int().nonnegative(),
|
|
1437
1326
|
policy: pickupPolicySchema
|
|
1438
1327
|
});
|
|
1439
|
-
var pickupAvailabilitySchema =
|
|
1440
|
-
|
|
1441
|
-
|
|
1442
|
-
kind:
|
|
1443
|
-
revision:
|
|
1444
|
-
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(
|
|
1445
1334
|
pickupAllocationSchema.extend({
|
|
1446
|
-
available:
|
|
1335
|
+
available: z14.number().int().nonnegative()
|
|
1447
1336
|
})
|
|
1448
1337
|
)
|
|
1449
1338
|
}).strict()
|
|
1450
1339
|
]);
|
|
1451
|
-
var configurePickupSchema =
|
|
1340
|
+
var configurePickupSchema = z14.object({
|
|
1452
1341
|
reward: identifier,
|
|
1453
|
-
revision:
|
|
1342
|
+
revision: z14.number().int().nonnegative(),
|
|
1454
1343
|
actionId: identifier,
|
|
1455
|
-
policy:
|
|
1456
|
-
|
|
1457
|
-
|
|
1458
|
-
kind:
|
|
1459
|
-
tiers:
|
|
1460
|
-
|
|
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({
|
|
1461
1350
|
tier: identifier,
|
|
1462
|
-
variants:
|
|
1351
|
+
variants: z14.array(
|
|
1463
1352
|
pickupAllocationSchema.extend({
|
|
1464
1353
|
item: identifier.optional()
|
|
1465
1354
|
})
|
|
@@ -1475,164 +1364,164 @@ var entitlementBase = {
|
|
|
1475
1364
|
reward: tieredRewardDefinitionSchema,
|
|
1476
1365
|
earnedTier: identifier,
|
|
1477
1366
|
tier: identifier,
|
|
1478
|
-
revision:
|
|
1367
|
+
revision: z14.number().int().positive()
|
|
1479
1368
|
};
|
|
1480
|
-
var entitlementSchema =
|
|
1481
|
-
|
|
1482
|
-
|
|
1369
|
+
var entitlementSchema = z14.discriminatedUnion("status", [
|
|
1370
|
+
z14.object({ ...entitlementBase, status: z14.literal("available") }).strict(),
|
|
1371
|
+
z14.object({
|
|
1483
1372
|
...entitlementBase,
|
|
1484
|
-
status:
|
|
1373
|
+
status: z14.literal("handing-over"),
|
|
1485
1374
|
handover: identifier,
|
|
1486
|
-
startedAt:
|
|
1375
|
+
startedAt: z14.number(),
|
|
1487
1376
|
allocation: pickupAllocationSchema.optional()
|
|
1488
1377
|
}).strict(),
|
|
1489
|
-
|
|
1378
|
+
z14.object({
|
|
1490
1379
|
...entitlementBase,
|
|
1491
|
-
status:
|
|
1380
|
+
status: z14.literal("collected"),
|
|
1492
1381
|
handover: identifier,
|
|
1493
|
-
startedAt:
|
|
1382
|
+
startedAt: z14.number(),
|
|
1494
1383
|
allocation: pickupAllocationSchema.optional(),
|
|
1495
|
-
collectedAt:
|
|
1384
|
+
collectedAt: z14.number()
|
|
1496
1385
|
}).strict()
|
|
1497
1386
|
]);
|
|
1498
|
-
var beginHandoverSchema =
|
|
1387
|
+
var beginHandoverSchema = z14.object({
|
|
1499
1388
|
actionId: identifier,
|
|
1500
|
-
revision:
|
|
1389
|
+
revision: z14.number().int().positive(),
|
|
1501
1390
|
selection: pickupSelectionSchema.optional()
|
|
1502
1391
|
}).strict();
|
|
1503
|
-
var confirmHandoverSchema =
|
|
1504
|
-
var completionRecordSchema =
|
|
1505
|
-
key:
|
|
1392
|
+
var confirmHandoverSchema = z14.object({ actionId: identifier, handover: identifier }).strict();
|
|
1393
|
+
var completionRecordSchema = z14.object({
|
|
1394
|
+
key: z14.string().default("once"),
|
|
1506
1395
|
id: identifier,
|
|
1507
1396
|
quest: identifier,
|
|
1508
1397
|
member: identifier
|
|
1509
1398
|
});
|
|
1510
|
-
var questAvailabilitySchema =
|
|
1511
|
-
|
|
1512
|
-
kind:
|
|
1513
|
-
input:
|
|
1399
|
+
var questAvailabilitySchema = z14.discriminatedUnion("kind", [
|
|
1400
|
+
z14.object({
|
|
1401
|
+
kind: z14.literal("available"),
|
|
1402
|
+
input: z14.enum(["photo", "quiz", "none", "text", "url"])
|
|
1514
1403
|
}).strict(),
|
|
1515
|
-
|
|
1516
|
-
|
|
1517
|
-
kind:
|
|
1518
|
-
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)
|
|
1519
1408
|
}).strict(),
|
|
1520
|
-
|
|
1521
|
-
|
|
1522
|
-
kind:
|
|
1409
|
+
z14.object({ kind: z14.literal("staff-required") }).strict(),
|
|
1410
|
+
z14.object({
|
|
1411
|
+
kind: z14.literal("automatic"),
|
|
1523
1412
|
observation: observationTriggerSchema.optional()
|
|
1524
1413
|
}).strict(),
|
|
1525
|
-
|
|
1526
|
-
|
|
1527
|
-
|
|
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()
|
|
1528
1417
|
]);
|
|
1529
|
-
var memberProgressSchema =
|
|
1418
|
+
var memberProgressSchema = z14.object({
|
|
1530
1419
|
member: identifier,
|
|
1531
|
-
quests:
|
|
1532
|
-
|
|
1420
|
+
quests: z14.array(
|
|
1421
|
+
z14.object({
|
|
1533
1422
|
quest: identifier,
|
|
1534
1423
|
key: identifier.optional(),
|
|
1535
1424
|
release: identifier.optional(),
|
|
1536
|
-
title:
|
|
1425
|
+
title: z14.string(),
|
|
1537
1426
|
presentation: questPresentationSchema.default({}),
|
|
1538
|
-
connections:
|
|
1427
|
+
connections: z14.array(authProviderSchema).default([]),
|
|
1539
1428
|
trigger: triggerSchema,
|
|
1540
1429
|
availability: questAvailabilitySchema,
|
|
1541
|
-
completed:
|
|
1430
|
+
completed: z14.boolean(),
|
|
1542
1431
|
completion: completionPolicySchema.default({ kind: "once" }),
|
|
1543
1432
|
streak: streakProgressSchema.nullable().optional(),
|
|
1544
|
-
completionCount:
|
|
1545
|
-
visibility:
|
|
1546
|
-
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() })),
|
|
1547
1436
|
attempt: attemptSchema.nullable()
|
|
1548
1437
|
})
|
|
1549
1438
|
),
|
|
1550
|
-
entitlements:
|
|
1439
|
+
entitlements: z14.array(entitlementSchema)
|
|
1551
1440
|
});
|
|
1552
|
-
var snapshotSchema =
|
|
1553
|
-
releases:
|
|
1554
|
-
completions:
|
|
1555
|
-
entitlements:
|
|
1556
|
-
attempts:
|
|
1557
|
-
balances:
|
|
1558
|
-
|
|
1559
|
-
member:
|
|
1560
|
-
balance:
|
|
1561
|
-
earned:
|
|
1562
|
-
held:
|
|
1563
|
-
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()
|
|
1564
1453
|
})
|
|
1565
1454
|
),
|
|
1566
|
-
events:
|
|
1455
|
+
events: z14.array(eventSchema)
|
|
1567
1456
|
});
|
|
1568
|
-
var evidenceSchema =
|
|
1457
|
+
var evidenceSchema = z14.object({
|
|
1569
1458
|
id: identifier,
|
|
1570
1459
|
member: identifier,
|
|
1571
|
-
type:
|
|
1572
|
-
size:
|
|
1460
|
+
type: z14.enum(["image/jpeg", "image/png"]),
|
|
1461
|
+
size: z14.number()
|
|
1573
1462
|
});
|
|
1574
|
-
var errorSchema =
|
|
1575
|
-
error:
|
|
1576
|
-
code:
|
|
1577
|
-
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()
|
|
1578
1467
|
});
|
|
1579
|
-
var staffDecisionSchema =
|
|
1468
|
+
var staffDecisionSchema = z14.object({
|
|
1580
1469
|
actionId: identifier,
|
|
1581
|
-
generation:
|
|
1582
|
-
decision:
|
|
1583
|
-
reason:
|
|
1470
|
+
generation: z14.number().int().nonnegative(),
|
|
1471
|
+
decision: z14.enum(["accept", "reject"]),
|
|
1472
|
+
reason: z14.string().trim().min(1).max(2e3)
|
|
1584
1473
|
}).strict();
|
|
1585
|
-
var stockSchema =
|
|
1586
|
-
var reservationSchema =
|
|
1474
|
+
var stockSchema = z14.object({ item: identifier, quantity: z14.number().int().min(0).max(1e4) }).strict();
|
|
1475
|
+
var reservationSchema = z14.object({
|
|
1587
1476
|
actionId: identifier,
|
|
1588
1477
|
member: identifier,
|
|
1589
1478
|
item: identifier,
|
|
1590
1479
|
balance: identifier,
|
|
1591
|
-
price:
|
|
1480
|
+
price: z14.number().int().positive().max(1e4)
|
|
1592
1481
|
}).strict();
|
|
1593
1482
|
var pageOptions = {
|
|
1594
|
-
limit:
|
|
1595
|
-
cursor:
|
|
1483
|
+
limit: z14.number().int().min(1).max(100).default(25),
|
|
1484
|
+
cursor: z14.string().min(1).max(4096).optional()
|
|
1596
1485
|
};
|
|
1597
|
-
var reviewListSchema =
|
|
1486
|
+
var reviewListSchema = z14.object({
|
|
1598
1487
|
...pageOptions,
|
|
1599
1488
|
member: identifier.optional(),
|
|
1600
1489
|
quest: identifier.optional()
|
|
1601
1490
|
}).strict();
|
|
1602
|
-
var memberListSchema =
|
|
1491
|
+
var memberListSchema = z14.object({
|
|
1603
1492
|
...pageOptions,
|
|
1604
1493
|
prefix: identifier.optional()
|
|
1605
1494
|
}).strict();
|
|
1606
|
-
var reviewItemSchema =
|
|
1495
|
+
var reviewItemSchema = z14.object({
|
|
1607
1496
|
attempt: attemptSchema,
|
|
1608
|
-
title:
|
|
1609
|
-
checks:
|
|
1610
|
-
|
|
1497
|
+
title: z14.string(),
|
|
1498
|
+
checks: z14.array(
|
|
1499
|
+
z14.object({ criteria: z14.string(), result: photoResultSchema })
|
|
1611
1500
|
)
|
|
1612
1501
|
});
|
|
1613
|
-
var reviewPageSchema =
|
|
1614
|
-
items:
|
|
1615
|
-
nextCursor:
|
|
1502
|
+
var reviewPageSchema = z14.object({
|
|
1503
|
+
items: z14.array(reviewItemSchema).max(100),
|
|
1504
|
+
nextCursor: z14.string().nullable()
|
|
1616
1505
|
});
|
|
1617
|
-
var memberPageSchema =
|
|
1618
|
-
items:
|
|
1619
|
-
nextCursor:
|
|
1506
|
+
var memberPageSchema = z14.object({
|
|
1507
|
+
items: z14.array(z14.object({ member: identifier })).max(100),
|
|
1508
|
+
nextCursor: z14.string().nullable()
|
|
1620
1509
|
});
|
|
1621
|
-
var createStockItemSchema =
|
|
1622
|
-
var stockItemSchema =
|
|
1623
|
-
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({
|
|
1624
1513
|
contentAttempt: identifier,
|
|
1625
1514
|
observation: identifier,
|
|
1626
|
-
observedAt:
|
|
1515
|
+
observedAt: z14.number().int().safe().nonnegative(),
|
|
1627
1516
|
metrics: contentMetricsSchema,
|
|
1628
1517
|
rewards: rewardBundleSchema
|
|
1629
1518
|
});
|
|
1630
1519
|
var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
|
|
1631
|
-
content:
|
|
1520
|
+
content: z14.string().min(1).max(256)
|
|
1632
1521
|
});
|
|
1633
|
-
var contentPerformancePageSchema =
|
|
1634
|
-
current:
|
|
1635
|
-
state:
|
|
1522
|
+
var contentPerformancePageSchema = z14.strictObject({
|
|
1523
|
+
current: z14.strictObject({
|
|
1524
|
+
state: z14.enum([
|
|
1636
1525
|
"content-pending",
|
|
1637
1526
|
"content-unqualified",
|
|
1638
1527
|
"waiting",
|
|
@@ -1643,19 +1532,19 @@ var contentPerformancePageSchema = z13.strictObject({
|
|
|
1643
1532
|
"failed",
|
|
1644
1533
|
"superseded"
|
|
1645
1534
|
]),
|
|
1646
|
-
reason:
|
|
1535
|
+
reason: z14.string().nullable(),
|
|
1647
1536
|
contentAttempt: identifier,
|
|
1648
1537
|
attempt: identifier.nullable(),
|
|
1649
1538
|
reward: contentQualificationSchema.shape.reward
|
|
1650
1539
|
}),
|
|
1651
|
-
items:
|
|
1652
|
-
|
|
1540
|
+
items: z14.array(
|
|
1541
|
+
z14.strictObject({
|
|
1653
1542
|
attempt: identifier,
|
|
1654
1543
|
contentAttempt: identifier,
|
|
1655
1544
|
observation: identifier,
|
|
1656
|
-
observedAt:
|
|
1545
|
+
observedAt: z14.number(),
|
|
1657
1546
|
metrics: contentMetricsSchema,
|
|
1658
|
-
state:
|
|
1547
|
+
state: z14.enum([
|
|
1659
1548
|
"pending",
|
|
1660
1549
|
"qualified",
|
|
1661
1550
|
"unqualified",
|
|
@@ -1663,13 +1552,18 @@ var contentPerformancePageSchema = z13.strictObject({
|
|
|
1663
1552
|
"failed",
|
|
1664
1553
|
"superseded"
|
|
1665
1554
|
]),
|
|
1666
|
-
reason:
|
|
1555
|
+
reason: z14.string().nullable()
|
|
1667
1556
|
})
|
|
1668
1557
|
),
|
|
1669
|
-
next:
|
|
1558
|
+
next: z14.number().int().positive().safe().nullable()
|
|
1670
1559
|
});
|
|
1671
1560
|
|
|
1672
1561
|
export {
|
|
1562
|
+
authProviderSchema,
|
|
1563
|
+
accountConnectionSchema,
|
|
1564
|
+
discordMemberInputSchema,
|
|
1565
|
+
discordMessageInputSchema,
|
|
1566
|
+
discordMemberSchema,
|
|
1673
1567
|
identifier,
|
|
1674
1568
|
xTweetSchema,
|
|
1675
1569
|
xContentBodySchema,
|
|
@@ -1684,11 +1578,8 @@ export {
|
|
|
1684
1578
|
customSourceSchema,
|
|
1685
1579
|
trackerSourceSchema,
|
|
1686
1580
|
sourceIdentities,
|
|
1687
|
-
x,
|
|
1688
|
-
customSource,
|
|
1689
1581
|
trackerDefinitionSchema,
|
|
1690
1582
|
trackerArtifactSchema,
|
|
1691
|
-
defineTracker,
|
|
1692
1583
|
publishedTrackerSchema,
|
|
1693
1584
|
trackerStatusSchema,
|
|
1694
1585
|
trackerControlSchema,
|
|
@@ -1709,16 +1600,13 @@ export {
|
|
|
1709
1600
|
trackerPreviewInputSchema,
|
|
1710
1601
|
trackerPreviewSchema,
|
|
1711
1602
|
contentPolicySchema,
|
|
1712
|
-
content,
|
|
1713
1603
|
admittedContentSchema,
|
|
1714
|
-
perContent,
|
|
1715
1604
|
contentEnrollmentInputSchema,
|
|
1716
1605
|
contentEnrollmentSchema,
|
|
1717
1606
|
contentReleaseInputSchema,
|
|
1718
1607
|
contentAdmissionSchema,
|
|
1719
1608
|
contentAdmissionQuerySchema,
|
|
1720
1609
|
contentAdmissionPageSchema,
|
|
1721
|
-
isContentParticipantRoute,
|
|
1722
1610
|
contentQualificationDecisionSchema,
|
|
1723
1611
|
contentQualificationQuerySchema,
|
|
1724
1612
|
contentQualificationSchema,
|
|
@@ -1728,7 +1616,6 @@ export {
|
|
|
1728
1616
|
contentPerformancePolicySchema,
|
|
1729
1617
|
communityTimeZoneSchema,
|
|
1730
1618
|
streakPolicySchema,
|
|
1731
|
-
streak,
|
|
1732
1619
|
streakProgressSchema,
|
|
1733
1620
|
trackerTriggerModeSchema,
|
|
1734
1621
|
defaultTriggerMode,
|
|
@@ -1752,11 +1639,6 @@ export {
|
|
|
1752
1639
|
integrationProviderSchema,
|
|
1753
1640
|
discordServerSchema,
|
|
1754
1641
|
projectIntegrationSchema,
|
|
1755
|
-
authProviderSchema,
|
|
1756
|
-
accountConnectionSchema,
|
|
1757
|
-
discordMemberInputSchema,
|
|
1758
|
-
discordMessageInputSchema,
|
|
1759
|
-
discordMemberSchema,
|
|
1760
1642
|
textOptionsSchema,
|
|
1761
1643
|
urlOptionsSchema,
|
|
1762
1644
|
textEvidenceSchema,
|
|
@@ -1771,12 +1653,11 @@ export {
|
|
|
1771
1653
|
resourceSourceSchema,
|
|
1772
1654
|
resourceRequestSchema,
|
|
1773
1655
|
resourceOptionsSchema,
|
|
1774
|
-
|
|
1775
|
-
|
|
1656
|
+
settingInstant,
|
|
1657
|
+
settingResourceId,
|
|
1776
1658
|
settingFieldSchema,
|
|
1777
1659
|
settingsFieldsSchema,
|
|
1778
1660
|
settingsValuesSchema,
|
|
1779
|
-
settings,
|
|
1780
1661
|
parseSettings,
|
|
1781
1662
|
missingResourceSettings,
|
|
1782
1663
|
compatibleSettingKinds,
|