@peasant-labs/schema 0.54.0 → 0.57.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +8 -0
- package/dist/internal/generated/contract/zod.gen.d.ts +3347 -3339
- package/dist/internal/generated/contract/zod.gen.js +235 -233
- package/dist/internal/generated/enums.gen.d.ts +704 -841
- package/dist/internal/generated/enums.gen.js +552 -552
- package/dist/internal/generated/versions.gen.d.ts +1 -1
- package/dist/internal/generated/versions.gen.js +1 -1
- package/dist/internal/generated/village-api.d.ts +90 -7
- package/package.json +1 -1
|
@@ -137,492 +137,492 @@ import { zAutoPublishRuleKind } from "./contract/zod.gen.js";
|
|
|
137
137
|
import { zThinkingLevel } from "./contract/zod.gen.js";
|
|
138
138
|
import { zScryVerdict } from "./contract/zod.gen.js";
|
|
139
139
|
export const TranscriptEntryReferenceKind = Object.freeze({
|
|
140
|
-
Source:
|
|
141
|
-
ToolCall:
|
|
142
|
-
ToolResult:
|
|
140
|
+
Source: "source",
|
|
141
|
+
ToolCall: "tool_call",
|
|
142
|
+
ToolResult: "tool_result",
|
|
143
143
|
});
|
|
144
144
|
export const AllTranscriptEntryReferenceKinds = Object.freeze([TranscriptEntryReferenceKind.Source, TranscriptEntryReferenceKind.ToolCall, TranscriptEntryReferenceKind.ToolResult]);
|
|
145
145
|
export function isTranscriptEntryReferenceKind(value) {
|
|
146
146
|
return zTranscriptEntryReferenceKind.safeParse(value).success;
|
|
147
147
|
}
|
|
148
148
|
export const TranscriptReadTransportKind = Object.freeze({
|
|
149
|
-
LocalSession:
|
|
150
|
-
VillageTranscript:
|
|
149
|
+
LocalSession: "local_session",
|
|
150
|
+
VillageTranscript: "village_transcript",
|
|
151
151
|
});
|
|
152
152
|
export const AllTranscriptReadTransportKinds = Object.freeze([TranscriptReadTransportKind.LocalSession, TranscriptReadTransportKind.VillageTranscript]);
|
|
153
153
|
export function isTranscriptReadTransportKind(value) {
|
|
154
154
|
return zTranscriptReadTransportKind.safeParse(value).success;
|
|
155
155
|
}
|
|
156
156
|
export const TranscriptRecordedIndexState = Object.freeze({
|
|
157
|
-
Present:
|
|
158
|
-
Absent:
|
|
159
|
-
Invalid:
|
|
157
|
+
Present: "present",
|
|
158
|
+
Absent: "absent",
|
|
159
|
+
Invalid: "invalid",
|
|
160
160
|
});
|
|
161
161
|
export const AllTranscriptRecordedIndexStates = Object.freeze([TranscriptRecordedIndexState.Present, TranscriptRecordedIndexState.Absent, TranscriptRecordedIndexState.Invalid]);
|
|
162
162
|
export function isTranscriptRecordedIndexState(value) {
|
|
163
163
|
return zTranscriptRecordedIndexState.safeParse(value).success;
|
|
164
164
|
}
|
|
165
165
|
export const TranscriptRetainedState = Object.freeze({
|
|
166
|
-
Absent:
|
|
167
|
-
Deferred:
|
|
166
|
+
Absent: "absent",
|
|
167
|
+
Deferred: "deferred",
|
|
168
168
|
});
|
|
169
169
|
export const AllTranscriptRetainedStates = Object.freeze([TranscriptRetainedState.Absent, TranscriptRetainedState.Deferred]);
|
|
170
170
|
export function isTranscriptRetainedState(value) {
|
|
171
171
|
return zTranscriptRetainedState.safeParse(value).success;
|
|
172
172
|
}
|
|
173
173
|
export const TranscriptViewerProjection = Object.freeze({
|
|
174
|
-
Anonymous:
|
|
175
|
-
Authenticated:
|
|
174
|
+
Anonymous: "anonymous",
|
|
175
|
+
Authenticated: "authenticated",
|
|
176
176
|
});
|
|
177
177
|
export const AllTranscriptViewerProjections = Object.freeze([TranscriptViewerProjection.Anonymous, TranscriptViewerProjection.Authenticated]);
|
|
178
178
|
export function isTranscriptViewerProjection(value) {
|
|
179
179
|
return zTranscriptViewerProjection.safeParse(value).success;
|
|
180
180
|
}
|
|
181
181
|
export const TranscriptReadValidation = Object.freeze({
|
|
182
|
-
PublishedStrict:
|
|
183
|
-
ServedLegacy:
|
|
184
|
-
Migrated:
|
|
182
|
+
PublishedStrict: "published_strict",
|
|
183
|
+
ServedLegacy: "served_legacy",
|
|
184
|
+
Migrated: "migrated",
|
|
185
185
|
});
|
|
186
186
|
export const AllTranscriptReadValidations = Object.freeze([TranscriptReadValidation.PublishedStrict, TranscriptReadValidation.ServedLegacy, TranscriptReadValidation.Migrated]);
|
|
187
187
|
export function isTranscriptReadValidation(value) {
|
|
188
188
|
return zTranscriptReadValidation.safeParse(value).success;
|
|
189
189
|
}
|
|
190
190
|
export const TranscriptNativePresence = Object.freeze({
|
|
191
|
-
Absent:
|
|
192
|
-
Present:
|
|
193
|
-
Withheld:
|
|
191
|
+
Absent: "absent",
|
|
192
|
+
Present: "present",
|
|
193
|
+
Withheld: "withheld",
|
|
194
194
|
});
|
|
195
195
|
export const AllTranscriptNativePresences = Object.freeze([TranscriptNativePresence.Absent, TranscriptNativePresence.Present, TranscriptNativePresence.Withheld]);
|
|
196
196
|
export function isTranscriptNativePresence(value) {
|
|
197
197
|
return zTranscriptNativePresence.safeParse(value).success;
|
|
198
198
|
}
|
|
199
199
|
export const TranscriptUsagePresence = Object.freeze({
|
|
200
|
-
Present:
|
|
201
|
-
Empty:
|
|
202
|
-
Unknown:
|
|
200
|
+
Present: "present",
|
|
201
|
+
Empty: "empty",
|
|
202
|
+
Unknown: "unknown",
|
|
203
203
|
});
|
|
204
204
|
export const AllTranscriptUsagePresences = Object.freeze([TranscriptUsagePresence.Present, TranscriptUsagePresence.Empty, TranscriptUsagePresence.Unknown]);
|
|
205
205
|
export function isTranscriptUsagePresence(value) {
|
|
206
206
|
return zTranscriptUsagePresence.safeParse(value).success;
|
|
207
207
|
}
|
|
208
208
|
export const TranscriptSegmentPartitionKind = Object.freeze({
|
|
209
|
-
Main:
|
|
210
|
-
History:
|
|
209
|
+
Main: "main",
|
|
210
|
+
History: "history",
|
|
211
211
|
});
|
|
212
212
|
export const AllTranscriptSegmentPartitionKinds = Object.freeze([TranscriptSegmentPartitionKind.Main, TranscriptSegmentPartitionKind.History]);
|
|
213
213
|
export function isTranscriptSegmentPartitionKind(value) {
|
|
214
214
|
return zTranscriptSegmentPartitionKind.safeParse(value).success;
|
|
215
215
|
}
|
|
216
216
|
export const CollectiveObservationReason = Object.freeze({
|
|
217
|
-
Membership:
|
|
218
|
-
Contribution:
|
|
219
|
-
Organization:
|
|
220
|
-
Explicit:
|
|
217
|
+
Membership: "membership",
|
|
218
|
+
Contribution: "contribution",
|
|
219
|
+
Organization: "organization",
|
|
220
|
+
Explicit: "explicit",
|
|
221
221
|
});
|
|
222
222
|
export const AllCollectiveObservationReasons = Object.freeze([CollectiveObservationReason.Membership, CollectiveObservationReason.Contribution, CollectiveObservationReason.Organization, CollectiveObservationReason.Explicit]);
|
|
223
223
|
export function isCollectiveObservationReason(value) {
|
|
224
224
|
return zCollectiveObservationReason.safeParse(value).success;
|
|
225
225
|
}
|
|
226
226
|
export const CollectiveObservationState = Object.freeze({
|
|
227
|
-
Observed:
|
|
228
|
-
Unavailable:
|
|
229
|
-
Invalidated:
|
|
227
|
+
Observed: "observed",
|
|
228
|
+
Unavailable: "unavailable",
|
|
229
|
+
Invalidated: "invalidated",
|
|
230
230
|
});
|
|
231
231
|
export const AllCollectiveObservationStates = Object.freeze([CollectiveObservationState.Observed, CollectiveObservationState.Unavailable, CollectiveObservationState.Invalidated]);
|
|
232
232
|
export function isCollectiveObservationState(value) {
|
|
233
233
|
return zCollectiveObservationState.safeParse(value).success;
|
|
234
234
|
}
|
|
235
235
|
export const CollectiveOperation = Object.freeze({
|
|
236
|
-
Publish:
|
|
237
|
-
Share:
|
|
238
|
-
Fetch:
|
|
239
|
-
Pull:
|
|
236
|
+
Publish: "publish",
|
|
237
|
+
Share: "share",
|
|
238
|
+
Fetch: "fetch",
|
|
239
|
+
Pull: "pull",
|
|
240
240
|
});
|
|
241
241
|
export const AllCollectiveOperations = Object.freeze([CollectiveOperation.Publish, CollectiveOperation.Share, CollectiveOperation.Fetch, CollectiveOperation.Pull]);
|
|
242
242
|
export function isCollectiveOperation(value) {
|
|
243
243
|
return zCollectiveOperation.safeParse(value).success;
|
|
244
244
|
}
|
|
245
245
|
export const OperationIssueCode = Object.freeze({
|
|
246
|
-
Auth:
|
|
247
|
-
Remote:
|
|
248
|
-
Contract:
|
|
249
|
-
Deadline:
|
|
250
|
-
Persistence:
|
|
251
|
-
Superseded:
|
|
246
|
+
Auth: "auth",
|
|
247
|
+
Remote: "remote",
|
|
248
|
+
Contract: "contract",
|
|
249
|
+
Deadline: "deadline",
|
|
250
|
+
Persistence: "persistence",
|
|
251
|
+
Superseded: "superseded",
|
|
252
252
|
});
|
|
253
253
|
export const AllOperationIssueCodes = Object.freeze([OperationIssueCode.Auth, OperationIssueCode.Remote, OperationIssueCode.Contract, OperationIssueCode.Deadline, OperationIssueCode.Persistence, OperationIssueCode.Superseded]);
|
|
254
254
|
export function isOperationIssueCode(value) {
|
|
255
255
|
return zOperationIssueCode.safeParse(value).success;
|
|
256
256
|
}
|
|
257
257
|
export const LocalContributionEvidenceKind = Object.freeze({
|
|
258
|
-
RemoteAttempts:
|
|
259
|
-
Receipts:
|
|
260
|
-
OperationDiagnostics:
|
|
258
|
+
RemoteAttempts: "remote-attempts",
|
|
259
|
+
Receipts: "receipts",
|
|
260
|
+
OperationDiagnostics: "operation-diagnostics",
|
|
261
261
|
});
|
|
262
262
|
export const AllLocalContributionEvidenceKinds = Object.freeze([LocalContributionEvidenceKind.RemoteAttempts, LocalContributionEvidenceKind.Receipts, LocalContributionEvidenceKind.OperationDiagnostics]);
|
|
263
263
|
export function isLocalContributionEvidenceKind(value) {
|
|
264
264
|
return zLocalContributionEvidenceKind.safeParse(value).success;
|
|
265
265
|
}
|
|
266
266
|
export const CollectiveEvidenceCoverage = Object.freeze({
|
|
267
|
-
Available:
|
|
268
|
-
Unknown:
|
|
267
|
+
Available: "available",
|
|
268
|
+
Unknown: "unknown",
|
|
269
269
|
});
|
|
270
270
|
export const AllCollectiveEvidenceCoverages = Object.freeze([CollectiveEvidenceCoverage.Available, CollectiveEvidenceCoverage.Unknown]);
|
|
271
271
|
export function isCollectiveEvidenceCoverage(value) {
|
|
272
272
|
return zCollectiveEvidenceCoverage.safeParse(value).success;
|
|
273
273
|
}
|
|
274
274
|
export const LocalConfirmedContributionOutcome = Object.freeze({
|
|
275
|
-
Published:
|
|
276
|
-
Submitted:
|
|
275
|
+
Published: "published",
|
|
276
|
+
Submitted: "submitted",
|
|
277
277
|
});
|
|
278
278
|
export const AllLocalConfirmedContributionOutcomes = Object.freeze([LocalConfirmedContributionOutcome.Published, LocalConfirmedContributionOutcome.Submitted]);
|
|
279
279
|
export function isLocalConfirmedContributionOutcome(value) {
|
|
280
280
|
return zLocalConfirmedContributionOutcome.safeParse(value).success;
|
|
281
281
|
}
|
|
282
282
|
export const LocalOperationDiagnosticOutcome = Object.freeze({
|
|
283
|
-
Failed:
|
|
284
|
-
Uncertain:
|
|
283
|
+
Failed: "failed",
|
|
284
|
+
Uncertain: "uncertain",
|
|
285
285
|
});
|
|
286
286
|
export const AllLocalOperationDiagnosticOutcomes = Object.freeze([LocalOperationDiagnosticOutcome.Failed, LocalOperationDiagnosticOutcome.Uncertain]);
|
|
287
287
|
export function isLocalOperationDiagnosticOutcome(value) {
|
|
288
288
|
return zLocalOperationDiagnosticOutcome.safeParse(value).success;
|
|
289
289
|
}
|
|
290
290
|
export const PullAssociationMetadataState = Object.freeze({
|
|
291
|
-
Observed:
|
|
292
|
-
Stale:
|
|
293
|
-
Unknown:
|
|
294
|
-
Invalidated:
|
|
291
|
+
Observed: "observed",
|
|
292
|
+
Stale: "stale",
|
|
293
|
+
Unknown: "unknown",
|
|
294
|
+
Invalidated: "invalidated",
|
|
295
295
|
});
|
|
296
296
|
export const AllPullAssociationMetadataStates = Object.freeze([PullAssociationMetadataState.Observed, PullAssociationMetadataState.Stale, PullAssociationMetadataState.Unknown, PullAssociationMetadataState.Invalidated]);
|
|
297
297
|
export function isPullAssociationMetadataState(value) {
|
|
298
298
|
return zPullAssociationMetadataState.safeParse(value).success;
|
|
299
299
|
}
|
|
300
300
|
export const CollectiveFetchDomain = Object.freeze({
|
|
301
|
-
Catalog:
|
|
302
|
-
History:
|
|
303
|
-
Associations:
|
|
301
|
+
Catalog: "catalog",
|
|
302
|
+
History: "history",
|
|
303
|
+
Associations: "associations",
|
|
304
304
|
});
|
|
305
305
|
export const AllCollectiveFetchDomains = Object.freeze([CollectiveFetchDomain.Catalog, CollectiveFetchDomain.History, CollectiveFetchDomain.Associations]);
|
|
306
306
|
export function isCollectiveFetchDomain(value) {
|
|
307
307
|
return zCollectiveFetchDomain.safeParse(value).success;
|
|
308
308
|
}
|
|
309
309
|
export const CollectiveFetchState = Object.freeze({
|
|
310
|
-
Complete:
|
|
311
|
-
Failed:
|
|
312
|
-
Cancelled:
|
|
313
|
-
Superseded:
|
|
314
|
-
NotRequested:
|
|
310
|
+
Complete: "complete",
|
|
311
|
+
Failed: "failed",
|
|
312
|
+
Cancelled: "cancelled",
|
|
313
|
+
Superseded: "superseded",
|
|
314
|
+
NotRequested: "not_requested",
|
|
315
315
|
});
|
|
316
316
|
export const AllCollectiveFetchStates = Object.freeze([CollectiveFetchState.Complete, CollectiveFetchState.Failed, CollectiveFetchState.Cancelled, CollectiveFetchState.Superseded, CollectiveFetchState.NotRequested]);
|
|
317
317
|
export function isCollectiveFetchState(value) {
|
|
318
318
|
return zCollectiveFetchState.safeParse(value).success;
|
|
319
319
|
}
|
|
320
320
|
export const CollectiveFetchCommit = Object.freeze({
|
|
321
|
-
Updated:
|
|
322
|
-
Unchanged:
|
|
323
|
-
Retained:
|
|
321
|
+
Updated: "updated",
|
|
322
|
+
Unchanged: "unchanged",
|
|
323
|
+
Retained: "retained",
|
|
324
324
|
});
|
|
325
325
|
export const AllCollectiveFetchCommits = Object.freeze([CollectiveFetchCommit.Updated, CollectiveFetchCommit.Unchanged, CollectiveFetchCommit.Retained]);
|
|
326
326
|
export function isCollectiveFetchCommit(value) {
|
|
327
327
|
return zCollectiveFetchCommit.safeParse(value).success;
|
|
328
328
|
}
|
|
329
329
|
export const CollectiveFetchOutcome = Object.freeze({
|
|
330
|
-
Complete:
|
|
331
|
-
Partial:
|
|
332
|
-
Failed:
|
|
330
|
+
Complete: "complete",
|
|
331
|
+
Partial: "partial",
|
|
332
|
+
Failed: "failed",
|
|
333
333
|
});
|
|
334
334
|
export const AllCollectiveFetchOutcomes = Object.freeze([CollectiveFetchOutcome.Complete, CollectiveFetchOutcome.Partial, CollectiveFetchOutcome.Failed]);
|
|
335
335
|
export function isCollectiveFetchOutcome(value) {
|
|
336
336
|
return zCollectiveFetchOutcome.safeParse(value).success;
|
|
337
337
|
}
|
|
338
338
|
export const CollectiveObservationSource = Object.freeze({
|
|
339
|
-
Membership:
|
|
340
|
-
ContributionDiscovery:
|
|
341
|
-
Organization:
|
|
342
|
-
Explicit:
|
|
343
|
-
Submissions:
|
|
344
|
-
Attempts:
|
|
345
|
-
Associations:
|
|
339
|
+
Membership: "membership",
|
|
340
|
+
ContributionDiscovery: "contribution-discovery",
|
|
341
|
+
Organization: "organization",
|
|
342
|
+
Explicit: "explicit",
|
|
343
|
+
Submissions: "submissions",
|
|
344
|
+
Attempts: "attempts",
|
|
345
|
+
Associations: "associations",
|
|
346
346
|
});
|
|
347
347
|
export const AllCollectiveObservationSources = Object.freeze([CollectiveObservationSource.Membership, CollectiveObservationSource.ContributionDiscovery, CollectiveObservationSource.Organization, CollectiveObservationSource.Explicit, CollectiveObservationSource.Submissions, CollectiveObservationSource.Attempts, CollectiveObservationSource.Associations]);
|
|
348
348
|
export function isCollectiveObservationSource(value) {
|
|
349
349
|
return zCollectiveObservationSource.safeParse(value).success;
|
|
350
350
|
}
|
|
351
351
|
export const CollectiveSourceOutcome = Object.freeze({
|
|
352
|
-
Disclosed:
|
|
353
|
-
NotDisclosed:
|
|
354
|
-
Failed:
|
|
352
|
+
Disclosed: "disclosed",
|
|
353
|
+
NotDisclosed: "not_disclosed",
|
|
354
|
+
Failed: "failed",
|
|
355
355
|
});
|
|
356
356
|
export const AllCollectiveSourceOutcomes = Object.freeze([CollectiveSourceOutcome.Disclosed, CollectiveSourceOutcome.NotDisclosed, CollectiveSourceOutcome.Failed]);
|
|
357
357
|
export function isCollectiveSourceOutcome(value) {
|
|
358
358
|
return zCollectiveSourceOutcome.safeParse(value).success;
|
|
359
359
|
}
|
|
360
360
|
export const LocalSyncPublicationFilter = Object.freeze({
|
|
361
|
-
All:
|
|
362
|
-
NotPublished:
|
|
363
|
-
Published:
|
|
364
|
-
Auto:
|
|
361
|
+
All: "all",
|
|
362
|
+
NotPublished: "not-published",
|
|
363
|
+
Published: "published",
|
|
364
|
+
Auto: "auto",
|
|
365
365
|
});
|
|
366
366
|
export const AllLocalSyncPublicationFilters = Object.freeze([LocalSyncPublicationFilter.All, LocalSyncPublicationFilter.NotPublished, LocalSyncPublicationFilter.Published, LocalSyncPublicationFilter.Auto]);
|
|
367
367
|
export function isLocalSyncPublicationFilter(value) {
|
|
368
368
|
return zLocalSyncPublicationFilter.safeParse(value).success;
|
|
369
369
|
}
|
|
370
370
|
export const PageSize = Object.freeze({
|
|
371
|
-
P25:
|
|
372
|
-
P50:
|
|
373
|
-
P100:
|
|
371
|
+
P25: 25,
|
|
372
|
+
P50: 50,
|
|
373
|
+
P100: 100,
|
|
374
374
|
});
|
|
375
375
|
export const AllPageSizes = Object.freeze([PageSize.P25, PageSize.P50, PageSize.P100]);
|
|
376
376
|
export function isPageSize(value) {
|
|
377
377
|
return zPageSize.safeParse(value).success;
|
|
378
378
|
}
|
|
379
379
|
export const PublishOperationKind = Object.freeze({
|
|
380
|
-
Preserve:
|
|
381
|
-
Replace:
|
|
382
|
-
Append:
|
|
380
|
+
Preserve: "preserve",
|
|
381
|
+
Replace: "replace",
|
|
382
|
+
Append: "append",
|
|
383
383
|
});
|
|
384
384
|
export const AllPublishOperationKinds = Object.freeze([PublishOperationKind.Preserve, PublishOperationKind.Replace, PublishOperationKind.Append]);
|
|
385
385
|
export function isPublishOperationKind(value) {
|
|
386
386
|
return zPublishOperationKind.safeParse(value).success;
|
|
387
387
|
}
|
|
388
388
|
export const VisibilityIntent = Object.freeze({
|
|
389
|
-
Private:
|
|
390
|
-
Public:
|
|
389
|
+
Private: "private",
|
|
390
|
+
Public: "public",
|
|
391
391
|
});
|
|
392
392
|
export const AllVisibilityIntents = Object.freeze([VisibilityIntent.Private, VisibilityIntent.Public]);
|
|
393
393
|
export function isVisibilityIntent(value) {
|
|
394
394
|
return zVisibilityIntent.safeParse(value).success;
|
|
395
395
|
}
|
|
396
396
|
export const AnnotationAxis = Object.freeze({
|
|
397
|
-
Type:
|
|
398
|
-
Session:
|
|
399
|
-
Project:
|
|
397
|
+
Type: "type",
|
|
398
|
+
Session: "session",
|
|
399
|
+
Project: "project",
|
|
400
400
|
});
|
|
401
401
|
export const AllAnnotationAxes = Object.freeze([AnnotationAxis.Type, AnnotationAxis.Session, AnnotationAxis.Project]);
|
|
402
402
|
export function isAnnotationAxis(value) {
|
|
403
403
|
return zAnnotationAxis.safeParse(value).success;
|
|
404
404
|
}
|
|
405
405
|
export const AnnotationDatatype = Object.freeze({
|
|
406
|
-
Text:
|
|
407
|
-
Integer:
|
|
408
|
-
Real:
|
|
409
|
-
Boolean:
|
|
406
|
+
Text: "text",
|
|
407
|
+
Integer: "integer",
|
|
408
|
+
Real: "real",
|
|
409
|
+
Boolean: "boolean",
|
|
410
410
|
});
|
|
411
411
|
export const AllAnnotationDatatypes = Object.freeze([AnnotationDatatype.Text, AnnotationDatatype.Integer, AnnotationDatatype.Real, AnnotationDatatype.Boolean]);
|
|
412
412
|
export function isAnnotationDatatype(value) {
|
|
413
413
|
return zAnnotationDatatype.safeParse(value).success;
|
|
414
414
|
}
|
|
415
415
|
export const AnnotationPushStatus = Object.freeze({
|
|
416
|
-
Created:
|
|
417
|
-
Updated:
|
|
418
|
-
Skipped:
|
|
419
|
-
Error:
|
|
416
|
+
Created: "created",
|
|
417
|
+
Updated: "updated",
|
|
418
|
+
Skipped: "skipped",
|
|
419
|
+
Error: "error",
|
|
420
420
|
});
|
|
421
421
|
export const AllAnnotationPushStatuses = Object.freeze([AnnotationPushStatus.Created, AnnotationPushStatus.Updated, AnnotationPushStatus.Skipped, AnnotationPushStatus.Error]);
|
|
422
422
|
export function isAnnotationPushStatus(value) {
|
|
423
423
|
return zAnnotationPushStatus.safeParse(value).success;
|
|
424
424
|
}
|
|
425
425
|
export const AnnotationStatus = Object.freeze({
|
|
426
|
-
Proposed:
|
|
427
|
-
Active:
|
|
428
|
-
Deprecated:
|
|
429
|
-
Retired:
|
|
426
|
+
Proposed: "proposed",
|
|
427
|
+
Active: "active",
|
|
428
|
+
Deprecated: "deprecated",
|
|
429
|
+
Retired: "retired",
|
|
430
430
|
});
|
|
431
431
|
export const AllAnnotationStatuses = Object.freeze([AnnotationStatus.Proposed, AnnotationStatus.Active, AnnotationStatus.Deprecated, AnnotationStatus.Retired]);
|
|
432
432
|
export function isAnnotationStatus(value) {
|
|
433
433
|
return zAnnotationStatus.safeParse(value).success;
|
|
434
434
|
}
|
|
435
435
|
export const AnnotatorKind = Object.freeze({
|
|
436
|
-
Human:
|
|
437
|
-
Agent:
|
|
438
|
-
Rule:
|
|
436
|
+
Human: "human",
|
|
437
|
+
Agent: "agent",
|
|
438
|
+
Rule: "rule",
|
|
439
439
|
});
|
|
440
440
|
export const AllAnnotatorKinds = Object.freeze([AnnotatorKind.Human, AnnotatorKind.Agent, AnnotatorKind.Rule]);
|
|
441
441
|
export function isAnnotatorKind(value) {
|
|
442
442
|
return zAnnotatorKind.safeParse(value).success;
|
|
443
443
|
}
|
|
444
444
|
export const AssociationConclusion = Object.freeze({
|
|
445
|
-
Confirmed:
|
|
446
|
-
Candidate:
|
|
445
|
+
Confirmed: "confirmed",
|
|
446
|
+
Candidate: "candidate",
|
|
447
447
|
});
|
|
448
448
|
export const AllAssociationConclusions = Object.freeze([AssociationConclusion.Confirmed, AssociationConclusion.Candidate]);
|
|
449
449
|
export function isAssociationConclusion(value) {
|
|
450
450
|
return zAssociationConclusion.safeParse(value).success;
|
|
451
451
|
}
|
|
452
452
|
export const AssociationEvidenceKind = Object.freeze({
|
|
453
|
-
RecordedCommit:
|
|
454
|
-
TouchedFile:
|
|
455
|
-
BranchMembership:
|
|
456
|
-
TimeWindow:
|
|
453
|
+
RecordedCommit: "recorded_commit",
|
|
454
|
+
TouchedFile: "touched_file",
|
|
455
|
+
BranchMembership: "branch_membership",
|
|
456
|
+
TimeWindow: "time_window",
|
|
457
457
|
});
|
|
458
458
|
export const AllAssociationEvidenceKinds = Object.freeze([AssociationEvidenceKind.RecordedCommit, AssociationEvidenceKind.TouchedFile, AssociationEvidenceKind.BranchMembership, AssociationEvidenceKind.TimeWindow]);
|
|
459
459
|
export function isAssociationEvidenceKind(value) {
|
|
460
460
|
return zAssociationEvidenceKind.safeParse(value).success;
|
|
461
461
|
}
|
|
462
462
|
export const BuiltinCommand = Object.freeze({
|
|
463
|
-
Exit:
|
|
464
|
-
Compact:
|
|
465
|
-
Clear:
|
|
466
|
-
New:
|
|
467
|
-
Model:
|
|
468
|
-
Usage:
|
|
469
|
-
Cost:
|
|
470
|
-
Context:
|
|
471
|
-
Plugin:
|
|
472
|
-
Permissions:
|
|
473
|
-
Login:
|
|
474
|
-
Resume:
|
|
475
|
-
Plan:
|
|
476
|
-
Fast:
|
|
477
|
-
Voice:
|
|
478
|
-
Todos:
|
|
479
|
-
ReloadPlugins:
|
|
480
|
-
Sandbox:
|
|
481
|
-
Config:
|
|
482
|
-
Statusline:
|
|
483
|
-
Upgrade:
|
|
484
|
-
ExtraUsage:
|
|
485
|
-
RateLimitOptions:
|
|
486
|
-
PrivacySettings:
|
|
487
|
-
Help:
|
|
488
|
-
Commands:
|
|
463
|
+
Exit: "exit",
|
|
464
|
+
Compact: "compact",
|
|
465
|
+
Clear: "clear",
|
|
466
|
+
New: "new",
|
|
467
|
+
Model: "model",
|
|
468
|
+
Usage: "usage",
|
|
469
|
+
Cost: "cost",
|
|
470
|
+
Context: "context",
|
|
471
|
+
Plugin: "plugin",
|
|
472
|
+
Permissions: "permissions",
|
|
473
|
+
Login: "login",
|
|
474
|
+
Resume: "resume",
|
|
475
|
+
Plan: "plan",
|
|
476
|
+
Fast: "fast",
|
|
477
|
+
Voice: "voice",
|
|
478
|
+
Todos: "todos",
|
|
479
|
+
ReloadPlugins: "reload-plugins",
|
|
480
|
+
Sandbox: "sandbox",
|
|
481
|
+
Config: "config",
|
|
482
|
+
Statusline: "statusline",
|
|
483
|
+
Upgrade: "upgrade",
|
|
484
|
+
ExtraUsage: "extra-usage",
|
|
485
|
+
RateLimitOptions: "rate-limit-options",
|
|
486
|
+
PrivacySettings: "privacy-settings",
|
|
487
|
+
Help: "help",
|
|
488
|
+
Commands: "commands",
|
|
489
489
|
});
|
|
490
490
|
export const AllClaudeBuiltinCmds = Object.freeze([BuiltinCommand.Exit, BuiltinCommand.Compact, BuiltinCommand.Clear, BuiltinCommand.New, BuiltinCommand.Model, BuiltinCommand.Usage, BuiltinCommand.Cost, BuiltinCommand.Context, BuiltinCommand.Plugin, BuiltinCommand.Permissions, BuiltinCommand.Login, BuiltinCommand.Resume, BuiltinCommand.Plan, BuiltinCommand.Fast, BuiltinCommand.Voice, BuiltinCommand.Todos, BuiltinCommand.ReloadPlugins, BuiltinCommand.Sandbox, BuiltinCommand.Config, BuiltinCommand.Statusline, BuiltinCommand.Upgrade, BuiltinCommand.ExtraUsage, BuiltinCommand.RateLimitOptions, BuiltinCommand.PrivacySettings, BuiltinCommand.Help, BuiltinCommand.Commands]);
|
|
491
491
|
export function isBuiltinCommand(value) {
|
|
492
492
|
return zBuiltinCommand.safeParse(value).success;
|
|
493
493
|
}
|
|
494
494
|
export const ChangeBinding = Object.freeze({
|
|
495
|
-
Bound:
|
|
496
|
-
Candidate:
|
|
495
|
+
Bound: "bound",
|
|
496
|
+
Candidate: "candidate",
|
|
497
497
|
});
|
|
498
498
|
export const AllChangeBindings = Object.freeze([ChangeBinding.Bound, ChangeBinding.Candidate]);
|
|
499
499
|
export function isChangeBinding(value) {
|
|
500
500
|
return zChangeBinding.safeParse(value).success;
|
|
501
501
|
}
|
|
502
502
|
export const ChannelTopic = Object.freeze({
|
|
503
|
-
Dashboard:
|
|
504
|
-
Sessions:
|
|
505
|
-
SessionDetail:
|
|
506
|
-
Trends:
|
|
507
|
-
Quality:
|
|
508
|
-
Annotations:
|
|
509
|
-
ProjectFamiliarity:
|
|
510
|
-
Kickstart:
|
|
503
|
+
Dashboard: "dashboard",
|
|
504
|
+
Sessions: "sessions",
|
|
505
|
+
SessionDetail: "session_detail",
|
|
506
|
+
Trends: "trends",
|
|
507
|
+
Quality: "quality",
|
|
508
|
+
Annotations: "annotations",
|
|
509
|
+
ProjectFamiliarity: "project_familiarity",
|
|
510
|
+
Kickstart: "kickstart",
|
|
511
511
|
});
|
|
512
512
|
export const AllChannelTopics = Object.freeze([ChannelTopic.Dashboard, ChannelTopic.Sessions, ChannelTopic.SessionDetail, ChannelTopic.Trends, ChannelTopic.Quality, ChannelTopic.Annotations, ChannelTopic.ProjectFamiliarity, ChannelTopic.Kickstart]);
|
|
513
513
|
export function isChannelTopic(value) {
|
|
514
514
|
return zChannelTopic.safeParse(value).success;
|
|
515
515
|
}
|
|
516
516
|
export const Confidence = Object.freeze({
|
|
517
|
-
High:
|
|
518
|
-
Medium:
|
|
519
|
-
Low:
|
|
517
|
+
High: "high",
|
|
518
|
+
Medium: "medium",
|
|
519
|
+
Low: "low",
|
|
520
520
|
});
|
|
521
521
|
export const AllConfidences = Object.freeze([Confidence.High, Confidence.Medium, Confidence.Low]);
|
|
522
522
|
export function isConfidence(value) {
|
|
523
523
|
return zConfidence.safeParse(value).success;
|
|
524
524
|
}
|
|
525
525
|
export const ContentKind = Object.freeze({
|
|
526
|
-
SessionDetail:
|
|
526
|
+
SessionDetail: "session_detail",
|
|
527
527
|
});
|
|
528
528
|
export const AllContentKinds = Object.freeze([ContentKind.SessionDetail]);
|
|
529
529
|
export function isContentKind(value) {
|
|
530
530
|
return zContentKind.safeParse(value).success;
|
|
531
531
|
}
|
|
532
532
|
export const DecayLevel = Object.freeze({
|
|
533
|
-
Fresh:
|
|
534
|
-
Fading:
|
|
535
|
-
Stale:
|
|
536
|
-
Unexplored:
|
|
533
|
+
Fresh: "fresh",
|
|
534
|
+
Fading: "fading",
|
|
535
|
+
Stale: "stale",
|
|
536
|
+
Unexplored: "unexplored",
|
|
537
537
|
});
|
|
538
538
|
export const AllDecayLevels = Object.freeze([DecayLevel.Fresh, DecayLevel.Fading, DecayLevel.Stale, DecayLevel.Unexplored]);
|
|
539
539
|
export function isDecayLevel(value) {
|
|
540
540
|
return zDecayLevel.safeParse(value).success;
|
|
541
541
|
}
|
|
542
542
|
export const DiffLineKind = Object.freeze({
|
|
543
|
-
Context:
|
|
544
|
-
Add:
|
|
545
|
-
Delete:
|
|
543
|
+
Context: "context",
|
|
544
|
+
Add: "add",
|
|
545
|
+
Delete: "del",
|
|
546
546
|
});
|
|
547
547
|
export const AllDiffLineKinds = Object.freeze([DiffLineKind.Context, DiffLineKind.Add, DiffLineKind.Delete]);
|
|
548
548
|
export function isDiffLineKind(value) {
|
|
549
549
|
return zDiffLineKind.safeParse(value).success;
|
|
550
550
|
}
|
|
551
551
|
export const EdgeViolationKind = Object.freeze({
|
|
552
|
-
Cycle:
|
|
553
|
-
WrongWay:
|
|
552
|
+
Cycle: "cycle",
|
|
553
|
+
WrongWay: "wrong_way",
|
|
554
554
|
});
|
|
555
555
|
export const AllEdgeViolationKinds = Object.freeze([EdgeViolationKind.Cycle, EdgeViolationKind.WrongWay]);
|
|
556
556
|
export function isEdgeViolationKind(value) {
|
|
557
557
|
return zEdgeViolationKind.safeParse(value).success;
|
|
558
558
|
}
|
|
559
559
|
export const EntryType = Object.freeze({
|
|
560
|
-
Text:
|
|
561
|
-
ToolUse:
|
|
562
|
-
ToolResult:
|
|
563
|
-
Thinking:
|
|
564
|
-
System:
|
|
565
|
-
Error:
|
|
566
|
-
Result:
|
|
567
|
-
Image:
|
|
560
|
+
Text: "text",
|
|
561
|
+
ToolUse: "tool_use",
|
|
562
|
+
ToolResult: "tool_result",
|
|
563
|
+
Thinking: "thinking",
|
|
564
|
+
System: "system",
|
|
565
|
+
Error: "error",
|
|
566
|
+
Result: "result",
|
|
567
|
+
Image: "image",
|
|
568
568
|
});
|
|
569
569
|
export const AllEntryTypes = Object.freeze([EntryType.Text, EntryType.ToolUse, EntryType.ToolResult, EntryType.Thinking, EntryType.System, EntryType.Error, EntryType.Result, EntryType.Image]);
|
|
570
570
|
export function isEntryType(value) {
|
|
571
571
|
return zEntryType.safeParse(value).success;
|
|
572
572
|
}
|
|
573
573
|
export const TurnPartType = Object.freeze({
|
|
574
|
-
Text:
|
|
575
|
-
Image:
|
|
574
|
+
Text: "text",
|
|
575
|
+
Image: "image",
|
|
576
576
|
});
|
|
577
577
|
export const AllTurnPartTypes = Object.freeze([TurnPartType.Text, TurnPartType.Image]);
|
|
578
578
|
export function isTurnPartType(value) {
|
|
579
579
|
return zTurnPartType.safeParse(value).success;
|
|
580
580
|
}
|
|
581
581
|
export const ImageMediaType = Object.freeze({
|
|
582
|
-
Png:
|
|
583
|
-
Jpeg:
|
|
582
|
+
Png: "image/png",
|
|
583
|
+
Jpeg: "image/jpeg",
|
|
584
584
|
});
|
|
585
585
|
export const AllImageMediaTypes = Object.freeze([ImageMediaType.Png, ImageMediaType.Jpeg]);
|
|
586
586
|
export function isImageMediaType(value) {
|
|
587
587
|
return zImageMediaType.safeParse(value).success;
|
|
588
588
|
}
|
|
589
589
|
export const OmittedReason = Object.freeze({
|
|
590
|
-
TooLarge:
|
|
591
|
-
Unsupported:
|
|
592
|
-
Missing:
|
|
593
|
-
NotPublished:
|
|
590
|
+
TooLarge: "too_large",
|
|
591
|
+
Unsupported: "unsupported",
|
|
592
|
+
Missing: "missing",
|
|
593
|
+
NotPublished: "not_published",
|
|
594
594
|
});
|
|
595
595
|
export const AllOmittedReasons = Object.freeze([OmittedReason.TooLarge, OmittedReason.Unsupported, OmittedReason.Missing, OmittedReason.NotPublished]);
|
|
596
596
|
export function isOmittedReason(value) {
|
|
597
597
|
return zOmittedReason.safeParse(value).success;
|
|
598
598
|
}
|
|
599
599
|
export const FileChangeStatus = Object.freeze({
|
|
600
|
-
Modified:
|
|
601
|
-
Added:
|
|
602
|
-
Deleted:
|
|
603
|
-
Renamed:
|
|
600
|
+
Modified: "M",
|
|
601
|
+
Added: "A",
|
|
602
|
+
Deleted: "D",
|
|
603
|
+
Renamed: "R",
|
|
604
604
|
});
|
|
605
605
|
export const AllFileChangeStatuses = Object.freeze([FileChangeStatus.Modified, FileChangeStatus.Added, FileChangeStatus.Deleted, FileChangeStatus.Renamed]);
|
|
606
606
|
export function isFileChangeStatus(value) {
|
|
607
607
|
return zFileChangeStatus.safeParse(value).success;
|
|
608
608
|
}
|
|
609
609
|
export const Harness = Object.freeze({
|
|
610
|
-
ClaudeCode:
|
|
611
|
-
GeminiCLI:
|
|
612
|
-
Codex:
|
|
613
|
-
OpenCode:
|
|
614
|
-
Cursor:
|
|
615
|
-
Antigravity:
|
|
616
|
-
Strike:
|
|
617
|
-
Pi:
|
|
618
|
-
GrokBuild:
|
|
619
|
-
DevinDesktop:
|
|
620
|
-
Cline:
|
|
621
|
-
Kiro:
|
|
622
|
-
KiroCLI:
|
|
623
|
-
KiroCrew:
|
|
624
|
-
AntigravityCLI:
|
|
625
|
-
AntigravityIDE:
|
|
610
|
+
ClaudeCode: "claude-code",
|
|
611
|
+
GeminiCLI: "gemini-cli",
|
|
612
|
+
Codex: "codex",
|
|
613
|
+
OpenCode: "opencode",
|
|
614
|
+
Cursor: "cursor",
|
|
615
|
+
Antigravity: "antigravity",
|
|
616
|
+
Strike: "strike",
|
|
617
|
+
Pi: "pi",
|
|
618
|
+
GrokBuild: "grok-build",
|
|
619
|
+
DevinDesktop: "devin-desktop",
|
|
620
|
+
Cline: "cline",
|
|
621
|
+
Kiro: "kiro",
|
|
622
|
+
KiroCLI: "kiro-cli",
|
|
623
|
+
KiroCrew: "kiro-crew",
|
|
624
|
+
AntigravityCLI: "antigravity-cli",
|
|
625
|
+
AntigravityIDE: "antigravity-ide",
|
|
626
626
|
});
|
|
627
627
|
/**
|
|
628
628
|
* AllHarnesses is the declared subset of Harness, not the full
|
|
@@ -635,882 +635,882 @@ export function isHarness(value) {
|
|
|
635
635
|
return zHarness.safeParse(value).success;
|
|
636
636
|
}
|
|
637
637
|
export const InsightKind = Object.freeze({
|
|
638
|
-
Decision:
|
|
639
|
-
Friction:
|
|
640
|
-
Unusual:
|
|
641
|
-
RetryLoop:
|
|
638
|
+
Decision: "decision",
|
|
639
|
+
Friction: "friction",
|
|
640
|
+
Unusual: "unusual",
|
|
641
|
+
RetryLoop: "retry_loop",
|
|
642
642
|
});
|
|
643
643
|
export const AllInsightKinds = Object.freeze([InsightKind.Decision, InsightKind.Friction, InsightKind.Unusual, InsightKind.RetryLoop]);
|
|
644
644
|
export function isInsightKind(value) {
|
|
645
645
|
return zInsightKind.safeParse(value).success;
|
|
646
646
|
}
|
|
647
647
|
export const InsightProvenance = Object.freeze({
|
|
648
|
-
Mechanical:
|
|
649
|
-
Mined:
|
|
648
|
+
Mechanical: "mechanical",
|
|
649
|
+
Mined: "mined",
|
|
650
650
|
});
|
|
651
651
|
export const AllInsightProvenances = Object.freeze([InsightProvenance.Mechanical, InsightProvenance.Mined]);
|
|
652
652
|
export function isInsightProvenance(value) {
|
|
653
653
|
return zInsightProvenance.safeParse(value).success;
|
|
654
654
|
}
|
|
655
655
|
export const InteractionType = Object.freeze({
|
|
656
|
-
Mentioned:
|
|
657
|
-
Read:
|
|
658
|
-
Discussed:
|
|
659
|
-
Questioned:
|
|
656
|
+
Mentioned: "mentioned",
|
|
657
|
+
Read: "read",
|
|
658
|
+
Discussed: "discussed",
|
|
659
|
+
Questioned: "questioned",
|
|
660
660
|
});
|
|
661
661
|
export const AllInteractionTypes = Object.freeze([InteractionType.Mentioned, InteractionType.Read, InteractionType.Discussed, InteractionType.Questioned]);
|
|
662
662
|
export function isInteractionType(value) {
|
|
663
663
|
return zInteractionType.safeParse(value).success;
|
|
664
664
|
}
|
|
665
665
|
export const License = Object.freeze({
|
|
666
|
-
CC0:
|
|
667
|
-
CCBY:
|
|
668
|
-
CCBYSA:
|
|
666
|
+
CC0: "CC0-1.0",
|
|
667
|
+
CCBY: "CC-BY-4.0",
|
|
668
|
+
CCBYSA: "CC-BY-SA-4.0",
|
|
669
669
|
});
|
|
670
670
|
export const AllLicenses = Object.freeze([License.CC0, License.CCBY, License.CCBYSA]);
|
|
671
671
|
export function isLicense(value) {
|
|
672
672
|
return zLicense.safeParse(value).success;
|
|
673
673
|
}
|
|
674
674
|
export const MapNodeKind = Object.freeze({
|
|
675
|
-
Module:
|
|
676
|
-
Package:
|
|
677
|
-
File:
|
|
675
|
+
Module: "module",
|
|
676
|
+
Package: "package",
|
|
677
|
+
File: "file",
|
|
678
678
|
});
|
|
679
679
|
export const AllMapNodeKinds = Object.freeze([MapNodeKind.Module, MapNodeKind.Package, MapNodeKind.File]);
|
|
680
680
|
export function isMapNodeKind(value) {
|
|
681
681
|
return zMapNodeKind.safeParse(value).success;
|
|
682
682
|
}
|
|
683
683
|
export const MessageType = Object.freeze({
|
|
684
|
-
Subscribe:
|
|
685
|
-
Unsubscribe:
|
|
686
|
-
Dashboard:
|
|
687
|
-
Sessions:
|
|
688
|
-
SessionDetail:
|
|
689
|
-
Trends:
|
|
690
|
-
Quality:
|
|
691
|
-
Annotations:
|
|
692
|
-
ProjectFamiliarity:
|
|
693
|
-
Connected:
|
|
694
|
-
Error:
|
|
695
|
-
Kickstart:
|
|
684
|
+
Subscribe: "subscribe",
|
|
685
|
+
Unsubscribe: "unsubscribe",
|
|
686
|
+
Dashboard: "dashboard",
|
|
687
|
+
Sessions: "sessions",
|
|
688
|
+
SessionDetail: "session_detail",
|
|
689
|
+
Trends: "trends",
|
|
690
|
+
Quality: "quality",
|
|
691
|
+
Annotations: "annotations",
|
|
692
|
+
ProjectFamiliarity: "project_familiarity",
|
|
693
|
+
Connected: "connected",
|
|
694
|
+
Error: "error",
|
|
695
|
+
Kickstart: "kickstart",
|
|
696
696
|
});
|
|
697
697
|
export const AllMessageTypes = Object.freeze([MessageType.Subscribe, MessageType.Unsubscribe, MessageType.Dashboard, MessageType.Sessions, MessageType.SessionDetail, MessageType.Trends, MessageType.Quality, MessageType.Annotations, MessageType.ProjectFamiliarity, MessageType.Connected, MessageType.Error, MessageType.Kickstart]);
|
|
698
698
|
export function isMessageType(value) {
|
|
699
699
|
return zMessageType.safeParse(value).success;
|
|
700
700
|
}
|
|
701
701
|
export const ReadAttributionState = Object.freeze({
|
|
702
|
-
Complete:
|
|
703
|
-
Partial:
|
|
704
|
-
Unavailable:
|
|
702
|
+
Complete: "complete",
|
|
703
|
+
Partial: "partial",
|
|
704
|
+
Unavailable: "unavailable",
|
|
705
705
|
});
|
|
706
706
|
export const AllReadAttributionStates = Object.freeze([ReadAttributionState.Complete, ReadAttributionState.Partial, ReadAttributionState.Unavailable]);
|
|
707
707
|
export function isReadAttributionState(value) {
|
|
708
708
|
return zReadAttributionState.safeParse(value).success;
|
|
709
709
|
}
|
|
710
710
|
export const ReadStateGrade = Object.freeze({
|
|
711
|
-
None:
|
|
712
|
-
Viewed:
|
|
713
|
-
Reviewed:
|
|
714
|
-
ReviewedInDetail:
|
|
711
|
+
None: "none",
|
|
712
|
+
Viewed: "viewed",
|
|
713
|
+
Reviewed: "reviewed",
|
|
714
|
+
ReviewedInDetail: "reviewed_in_detail",
|
|
715
715
|
});
|
|
716
716
|
export const AllReadStateGrades = Object.freeze([ReadStateGrade.None, ReadStateGrade.Viewed, ReadStateGrade.Reviewed, ReadStateGrade.ReviewedInDetail]);
|
|
717
717
|
export function isReadStateGrade(value) {
|
|
718
718
|
return zReadStateGrade.safeParse(value).success;
|
|
719
719
|
}
|
|
720
720
|
export const RewriteMethod = Object.freeze({
|
|
721
|
-
Hash:
|
|
722
|
-
PatchID:
|
|
723
|
-
AuthorIdentity:
|
|
724
|
-
MessageEmbedded:
|
|
725
|
-
Temporal:
|
|
726
|
-
None:
|
|
721
|
+
Hash: "hash",
|
|
722
|
+
PatchID: "patch_id",
|
|
723
|
+
AuthorIdentity: "author_identity",
|
|
724
|
+
MessageEmbedded: "message_embedded",
|
|
725
|
+
Temporal: "temporal",
|
|
726
|
+
None: "none",
|
|
727
727
|
});
|
|
728
728
|
export const AllRewriteMethods = Object.freeze([RewriteMethod.Hash, RewriteMethod.PatchID, RewriteMethod.AuthorIdentity, RewriteMethod.MessageEmbedded, RewriteMethod.Temporal, RewriteMethod.None]);
|
|
729
729
|
export function isRewriteMethod(value) {
|
|
730
730
|
return zRewriteMethod.safeParse(value).success;
|
|
731
731
|
}
|
|
732
732
|
export const RewriteResolution = Object.freeze({
|
|
733
|
-
Live:
|
|
734
|
-
Rewritten:
|
|
735
|
-
Unresolved:
|
|
733
|
+
Live: "live",
|
|
734
|
+
Rewritten: "rewritten",
|
|
735
|
+
Unresolved: "unresolved",
|
|
736
736
|
});
|
|
737
737
|
export const AllRewriteResolutions = Object.freeze([RewriteResolution.Live, RewriteResolution.Rewritten, RewriteResolution.Unresolved]);
|
|
738
738
|
export function isRewriteResolution(value) {
|
|
739
739
|
return zRewriteResolution.safeParse(value).success;
|
|
740
740
|
}
|
|
741
741
|
export const Role = Object.freeze({
|
|
742
|
-
User:
|
|
743
|
-
Assistant:
|
|
744
|
-
Tool:
|
|
745
|
-
System:
|
|
742
|
+
User: "user",
|
|
743
|
+
Assistant: "assistant",
|
|
744
|
+
Tool: "tool",
|
|
745
|
+
System: "system",
|
|
746
746
|
});
|
|
747
747
|
export const AllRoles = Object.freeze([Role.User, Role.Assistant, Role.Tool, Role.System]);
|
|
748
748
|
export function isRole(value) {
|
|
749
749
|
return zRole.safeParse(value).success;
|
|
750
750
|
}
|
|
751
751
|
export const ScaleKind = Object.freeze({
|
|
752
|
-
Nominal:
|
|
753
|
-
Ordinal:
|
|
754
|
-
Continuous:
|
|
752
|
+
Nominal: "nominal",
|
|
753
|
+
Ordinal: "ordinal",
|
|
754
|
+
Continuous: "continuous",
|
|
755
755
|
});
|
|
756
756
|
export const AllScaleKinds = Object.freeze([ScaleKind.Nominal, ScaleKind.Ordinal, ScaleKind.Continuous]);
|
|
757
757
|
export function isScaleKind(value) {
|
|
758
758
|
return zScaleKind.safeParse(value).success;
|
|
759
759
|
}
|
|
760
760
|
export const SessionOrigin = Object.freeze({
|
|
761
|
-
User:
|
|
762
|
-
Agent:
|
|
763
|
-
Unknown:
|
|
761
|
+
User: "user",
|
|
762
|
+
Agent: "agent",
|
|
763
|
+
Unknown: "unknown",
|
|
764
764
|
});
|
|
765
765
|
export const AllSessionOrigins = Object.freeze([SessionOrigin.User, SessionOrigin.Agent, SessionOrigin.Unknown]);
|
|
766
766
|
export function isSessionOrigin(value) {
|
|
767
767
|
return zSessionOrigin.safeParse(value).success;
|
|
768
768
|
}
|
|
769
769
|
export const SessionOutcome = Object.freeze({
|
|
770
|
-
Resolved:
|
|
771
|
-
Partial:
|
|
772
|
-
Failed:
|
|
770
|
+
Resolved: "resolved",
|
|
771
|
+
Partial: "partial",
|
|
772
|
+
Failed: "failed",
|
|
773
773
|
});
|
|
774
774
|
export const AllOutcomes = Object.freeze([SessionOutcome.Resolved, SessionOutcome.Partial, SessionOutcome.Failed]);
|
|
775
775
|
export function isSessionOutcome(value) {
|
|
776
776
|
return zSessionOutcome.safeParse(value).success;
|
|
777
777
|
}
|
|
778
778
|
export const SourceFormat = Object.freeze({
|
|
779
|
-
JSONL:
|
|
780
|
-
JSON:
|
|
779
|
+
JSONL: "jsonl",
|
|
780
|
+
JSON: "json",
|
|
781
781
|
});
|
|
782
782
|
export const AllSourceFormats = Object.freeze([SourceFormat.JSONL, SourceFormat.JSON]);
|
|
783
783
|
export function isSourceFormat(value) {
|
|
784
784
|
return zSourceFormat.safeParse(value).success;
|
|
785
785
|
}
|
|
786
786
|
export const StopReason = Object.freeze({
|
|
787
|
-
EndTurn:
|
|
788
|
-
Cancelled:
|
|
789
|
-
MaxTokens:
|
|
790
|
-
MaxTurnRequests:
|
|
791
|
-
Refusal:
|
|
787
|
+
EndTurn: "end_turn",
|
|
788
|
+
Cancelled: "cancelled",
|
|
789
|
+
MaxTokens: "max_tokens",
|
|
790
|
+
MaxTurnRequests: "max_turn_requests",
|
|
791
|
+
Refusal: "refusal",
|
|
792
792
|
});
|
|
793
793
|
export const AllStopReasons = Object.freeze([StopReason.EndTurn, StopReason.Cancelled, StopReason.MaxTokens, StopReason.MaxTurnRequests, StopReason.Refusal]);
|
|
794
794
|
export function isStopReason(value) {
|
|
795
795
|
return zStopReason.safeParse(value).success;
|
|
796
796
|
}
|
|
797
797
|
export const TargetKind = Object.freeze({
|
|
798
|
-
Session:
|
|
799
|
-
Entry:
|
|
800
|
-
Annotation:
|
|
801
|
-
Project:
|
|
802
|
-
FileVersion:
|
|
803
|
-
Association:
|
|
798
|
+
Session: "session",
|
|
799
|
+
Entry: "entry",
|
|
800
|
+
Annotation: "annotation",
|
|
801
|
+
Project: "project",
|
|
802
|
+
FileVersion: "file_version",
|
|
803
|
+
Association: "association",
|
|
804
804
|
});
|
|
805
805
|
export const AllTargetKinds = Object.freeze([TargetKind.Session, TargetKind.Entry, TargetKind.Annotation, TargetKind.Project, TargetKind.FileVersion, TargetKind.Association]);
|
|
806
806
|
export function isTargetKind(value) {
|
|
807
807
|
return zTargetKind.safeParse(value).success;
|
|
808
808
|
}
|
|
809
809
|
export const ToolCallKind = Object.freeze({
|
|
810
|
-
Read:
|
|
811
|
-
Edit:
|
|
812
|
-
Delete:
|
|
813
|
-
Move:
|
|
814
|
-
Search:
|
|
815
|
-
Execute:
|
|
816
|
-
Think:
|
|
817
|
-
Fetch:
|
|
818
|
-
Other:
|
|
810
|
+
Read: "read",
|
|
811
|
+
Edit: "edit",
|
|
812
|
+
Delete: "delete",
|
|
813
|
+
Move: "move",
|
|
814
|
+
Search: "search",
|
|
815
|
+
Execute: "execute",
|
|
816
|
+
Think: "think",
|
|
817
|
+
Fetch: "fetch",
|
|
818
|
+
Other: "other",
|
|
819
819
|
});
|
|
820
820
|
export const AllToolCallKinds = Object.freeze([ToolCallKind.Read, ToolCallKind.Edit, ToolCallKind.Delete, ToolCallKind.Move, ToolCallKind.Search, ToolCallKind.Execute, ToolCallKind.Think, ToolCallKind.Fetch, ToolCallKind.Other]);
|
|
821
821
|
export function isToolCallKind(value) {
|
|
822
822
|
return zToolCallKind.safeParse(value).success;
|
|
823
823
|
}
|
|
824
824
|
export const TypeOrigin = Object.freeze({
|
|
825
|
-
System:
|
|
826
|
-
User:
|
|
827
|
-
Group:
|
|
825
|
+
System: "system",
|
|
826
|
+
User: "user",
|
|
827
|
+
Group: "group",
|
|
828
828
|
});
|
|
829
829
|
export const AllTypeOrigins = Object.freeze([TypeOrigin.System, TypeOrigin.User, TypeOrigin.Group]);
|
|
830
830
|
export function isTypeOrigin(value) {
|
|
831
831
|
return zTypeOrigin.safeParse(value).success;
|
|
832
832
|
}
|
|
833
833
|
export const ValueDomainKind = Object.freeze({
|
|
834
|
-
Enumerated:
|
|
835
|
-
Described:
|
|
834
|
+
Enumerated: "enumerated",
|
|
835
|
+
Described: "described",
|
|
836
836
|
});
|
|
837
837
|
export const AllValueDomainKinds = Object.freeze([ValueDomainKind.Enumerated, ValueDomainKind.Described]);
|
|
838
838
|
export function isValueDomainKind(value) {
|
|
839
839
|
return zValueDomainKind.safeParse(value).success;
|
|
840
840
|
}
|
|
841
841
|
export const TranscriptUpdateLicense = Object.freeze({
|
|
842
|
-
Clear:
|
|
843
|
-
CC0:
|
|
844
|
-
CCBY:
|
|
845
|
-
CCBYSA:
|
|
842
|
+
Clear: "",
|
|
843
|
+
CC0: "CC0-1.0",
|
|
844
|
+
CCBY: "CC-BY-4.0",
|
|
845
|
+
CCBYSA: "CC-BY-SA-4.0",
|
|
846
846
|
});
|
|
847
847
|
export const AllTranscriptUpdateLicenses = Object.freeze([TranscriptUpdateLicense.Clear, TranscriptUpdateLicense.CC0, TranscriptUpdateLicense.CCBY, TranscriptUpdateLicense.CCBYSA]);
|
|
848
848
|
export function isTranscriptUpdateLicense(value) {
|
|
849
849
|
return zTranscriptUpdateLicense.safeParse(value).success;
|
|
850
850
|
}
|
|
851
851
|
export const TranscriptUpdateVisibility = Object.freeze({
|
|
852
|
-
Private:
|
|
853
|
-
Public:
|
|
852
|
+
Private: "private",
|
|
853
|
+
Public: "public",
|
|
854
854
|
});
|
|
855
855
|
export const AllTranscriptUpdateVisibilities = Object.freeze([TranscriptUpdateVisibility.Private, TranscriptUpdateVisibility.Public]);
|
|
856
856
|
export function isTranscriptUpdateVisibility(value) {
|
|
857
857
|
return zTranscriptUpdateVisibility.safeParse(value).success;
|
|
858
858
|
}
|
|
859
859
|
export const VillageAssignableCollectiveRole = Object.freeze({
|
|
860
|
-
Contributor:
|
|
861
|
-
Member:
|
|
860
|
+
Contributor: "contributor",
|
|
861
|
+
Member: "member",
|
|
862
862
|
});
|
|
863
863
|
export const AllVillageAssignableCollectiveRoles = Object.freeze([VillageAssignableCollectiveRole.Contributor, VillageAssignableCollectiveRole.Member]);
|
|
864
864
|
export function isVillageAssignableCollectiveRole(value) {
|
|
865
865
|
return zVillageAssignableCollectiveRole.safeParse(value).success;
|
|
866
866
|
}
|
|
867
867
|
export const VillageContributionStatus = Object.freeze({
|
|
868
|
-
Approved:
|
|
869
|
-
Pending:
|
|
868
|
+
Approved: "approved",
|
|
869
|
+
Pending: "pending",
|
|
870
870
|
});
|
|
871
871
|
export const AllVillageContributionStatuses = Object.freeze([VillageContributionStatus.Approved, VillageContributionStatus.Pending]);
|
|
872
872
|
export function isVillageContributionStatus(value) {
|
|
873
873
|
return zVillageContributionStatus.safeParse(value).success;
|
|
874
874
|
}
|
|
875
875
|
export const VillageCollectiveAcceptanceMode = Object.freeze({
|
|
876
|
-
Open:
|
|
877
|
-
VerifiedOnly:
|
|
878
|
-
Curated:
|
|
876
|
+
Open: "open",
|
|
877
|
+
VerifiedOnly: "verified_only",
|
|
878
|
+
Curated: "curated",
|
|
879
879
|
});
|
|
880
880
|
export const AllVillageCollectiveAcceptanceModes = Object.freeze([VillageCollectiveAcceptanceMode.Open, VillageCollectiveAcceptanceMode.VerifiedOnly, VillageCollectiveAcceptanceMode.Curated]);
|
|
881
881
|
export function isVillageCollectiveAcceptanceMode(value) {
|
|
882
882
|
return zVillageCollectiveAcceptanceMode.safeParse(value).success;
|
|
883
883
|
}
|
|
884
884
|
export const VillageCollectiveDataAccess = Object.freeze({
|
|
885
|
-
MembersOnly:
|
|
886
|
-
Contributors:
|
|
887
|
-
Public:
|
|
885
|
+
MembersOnly: "members_only",
|
|
886
|
+
Contributors: "contributors",
|
|
887
|
+
Public: "public",
|
|
888
888
|
});
|
|
889
889
|
export const AllVillageCollectiveDataAccessPolicies = Object.freeze([VillageCollectiveDataAccess.MembersOnly, VillageCollectiveDataAccess.Contributors, VillageCollectiveDataAccess.Public]);
|
|
890
890
|
export function isVillageCollectiveDataAccess(value) {
|
|
891
891
|
return zVillageCollectiveDataAccess.safeParse(value).success;
|
|
892
892
|
}
|
|
893
893
|
export const VillageCollectiveRole = Object.freeze({
|
|
894
|
-
Owner:
|
|
895
|
-
Member:
|
|
896
|
-
Contributor:
|
|
897
|
-
Pending:
|
|
894
|
+
Owner: "owner",
|
|
895
|
+
Member: "member",
|
|
896
|
+
Contributor: "contributor",
|
|
897
|
+
Pending: "pending",
|
|
898
898
|
});
|
|
899
899
|
export const AllVillageCollectiveRoles = Object.freeze([VillageCollectiveRole.Owner, VillageCollectiveRole.Member, VillageCollectiveRole.Contributor, VillageCollectiveRole.Pending]);
|
|
900
900
|
export function isVillageCollectiveRole(value) {
|
|
901
901
|
return zVillageCollectiveRole.safeParse(value).success;
|
|
902
902
|
}
|
|
903
903
|
export const VillageCollectiveViewerRole = Object.freeze({
|
|
904
|
-
None:
|
|
905
|
-
Owner:
|
|
906
|
-
Member:
|
|
907
|
-
Contributor:
|
|
908
|
-
Pending:
|
|
904
|
+
None: "",
|
|
905
|
+
Owner: "owner",
|
|
906
|
+
Member: "member",
|
|
907
|
+
Contributor: "contributor",
|
|
908
|
+
Pending: "pending",
|
|
909
909
|
});
|
|
910
910
|
export const AllVillageCollectiveViewerRoles = Object.freeze([VillageCollectiveViewerRole.None, VillageCollectiveViewerRole.Owner, VillageCollectiveViewerRole.Member, VillageCollectiveViewerRole.Contributor, VillageCollectiveViewerRole.Pending]);
|
|
911
911
|
export function isVillageCollectiveViewerRole(value) {
|
|
912
912
|
return zVillageCollectiveViewerRole.safeParse(value).success;
|
|
913
913
|
}
|
|
914
914
|
export const VillageProjectNameSource = Object.freeze({
|
|
915
|
-
Override:
|
|
916
|
-
Consented:
|
|
917
|
-
Remote:
|
|
918
|
-
Path:
|
|
919
|
-
Privacy:
|
|
915
|
+
Override: "override",
|
|
916
|
+
Consented: "consented",
|
|
917
|
+
Remote: "remote",
|
|
918
|
+
Path: "path",
|
|
919
|
+
Privacy: "privacy",
|
|
920
920
|
});
|
|
921
921
|
export const AllVillageProjectNameSources = Object.freeze([VillageProjectNameSource.Override, VillageProjectNameSource.Consented, VillageProjectNameSource.Remote, VillageProjectNameSource.Path, VillageProjectNameSource.Privacy]);
|
|
922
922
|
export function isVillageProjectNameSource(value) {
|
|
923
923
|
return zVillageProjectNameSource.safeParse(value).success;
|
|
924
924
|
}
|
|
925
925
|
export const VillageReviewDecision = Object.freeze({
|
|
926
|
-
Approved:
|
|
927
|
-
Rejected:
|
|
926
|
+
Approved: "approved",
|
|
927
|
+
Rejected: "rejected",
|
|
928
928
|
});
|
|
929
929
|
export const AllVillageReviewDecisions = Object.freeze([VillageReviewDecision.Approved, VillageReviewDecision.Rejected]);
|
|
930
930
|
export function isVillageReviewDecision(value) {
|
|
931
931
|
return zVillageReviewDecision.safeParse(value).success;
|
|
932
932
|
}
|
|
933
933
|
export const VillageShareEventActor = Object.freeze({
|
|
934
|
-
None:
|
|
935
|
-
Owner:
|
|
936
|
-
Collective:
|
|
937
|
-
Moderator:
|
|
934
|
+
None: "",
|
|
935
|
+
Owner: "owner",
|
|
936
|
+
Collective: "collective",
|
|
937
|
+
Moderator: "moderator",
|
|
938
938
|
});
|
|
939
939
|
export const AllVillageShareEventActors = Object.freeze([VillageShareEventActor.None, VillageShareEventActor.Owner, VillageShareEventActor.Collective, VillageShareEventActor.Moderator]);
|
|
940
940
|
export function isVillageShareEventActor(value) {
|
|
941
941
|
return zVillageShareEventActor.safeParse(value).success;
|
|
942
942
|
}
|
|
943
943
|
export const VillageShareStatus = Object.freeze({
|
|
944
|
-
Pending:
|
|
945
|
-
Approved:
|
|
946
|
-
Rejected:
|
|
947
|
-
Retracted:
|
|
948
|
-
Revoked:
|
|
944
|
+
Pending: "pending",
|
|
945
|
+
Approved: "approved",
|
|
946
|
+
Rejected: "rejected",
|
|
947
|
+
Retracted: "retracted",
|
|
948
|
+
Revoked: "revoked",
|
|
949
949
|
});
|
|
950
950
|
export const AllVillageShareStatuses = Object.freeze([VillageShareStatus.Pending, VillageShareStatus.Approved, VillageShareStatus.Rejected, VillageShareStatus.Retracted, VillageShareStatus.Revoked]);
|
|
951
951
|
export function isVillageShareStatus(value) {
|
|
952
952
|
return zVillageShareStatus.safeParse(value).success;
|
|
953
953
|
}
|
|
954
954
|
export const VillageTranscriptDeletionPolicy = Object.freeze({
|
|
955
|
-
UserChoice:
|
|
956
|
-
Mandatory:
|
|
955
|
+
UserChoice: "user_choice",
|
|
956
|
+
Mandatory: "mandatory",
|
|
957
957
|
});
|
|
958
958
|
export const AllVillageTranscriptDeletionPolicies = Object.freeze([VillageTranscriptDeletionPolicy.UserChoice, VillageTranscriptDeletionPolicy.Mandatory]);
|
|
959
959
|
export function isVillageTranscriptDeletionPolicy(value) {
|
|
960
960
|
return zVillageTranscriptDeletionPolicy.safeParse(value).success;
|
|
961
961
|
}
|
|
962
962
|
export const VillageTranscriptVisibility = Object.freeze({
|
|
963
|
-
Private:
|
|
964
|
-
Shared:
|
|
965
|
-
Public:
|
|
963
|
+
Private: "private",
|
|
964
|
+
Shared: "shared",
|
|
965
|
+
Public: "public",
|
|
966
966
|
});
|
|
967
967
|
export const AllVillageTranscriptVisibilities = Object.freeze([VillageTranscriptVisibility.Private, VillageTranscriptVisibility.Shared, VillageTranscriptVisibility.Public]);
|
|
968
968
|
export function isVillageTranscriptVisibility(value) {
|
|
969
969
|
return zVillageTranscriptVisibility.safeParse(value).success;
|
|
970
970
|
}
|
|
971
971
|
export const Visibility = Object.freeze({
|
|
972
|
-
Private:
|
|
973
|
-
Group:
|
|
974
|
-
Public:
|
|
972
|
+
Private: "private",
|
|
973
|
+
Group: "group",
|
|
974
|
+
Public: "public",
|
|
975
975
|
});
|
|
976
976
|
export const AllVisibilities = Object.freeze([Visibility.Private, Visibility.Group, Visibility.Public]);
|
|
977
977
|
export function isVisibility(value) {
|
|
978
978
|
return zVisibility.safeParse(value).success;
|
|
979
979
|
}
|
|
980
980
|
export const UsageScope = Object.freeze({
|
|
981
|
-
Assistant:
|
|
982
|
-
Tool:
|
|
983
|
-
Summary:
|
|
981
|
+
Assistant: "assistant",
|
|
982
|
+
Tool: "tool",
|
|
983
|
+
Summary: "summary",
|
|
984
984
|
});
|
|
985
985
|
export const AllUsageScopes = Object.freeze([UsageScope.Assistant, UsageScope.Tool, UsageScope.Summary]);
|
|
986
986
|
export function isUsageScope(value) {
|
|
987
987
|
return zUsageScope.safeParse(value).success;
|
|
988
988
|
}
|
|
989
989
|
export const UsageCompleteness = Object.freeze({
|
|
990
|
-
Complete:
|
|
991
|
-
Partial:
|
|
992
|
-
Unknown:
|
|
990
|
+
Complete: "complete",
|
|
991
|
+
Partial: "partial",
|
|
992
|
+
Unknown: "unknown",
|
|
993
993
|
});
|
|
994
994
|
export const AllUsageCompleteness = Object.freeze([UsageCompleteness.Complete, UsageCompleteness.Partial, UsageCompleteness.Unknown]);
|
|
995
995
|
export function isUsageCompleteness(value) {
|
|
996
996
|
return zUsageCompleteness.safeParse(value).success;
|
|
997
997
|
}
|
|
998
998
|
export const NativeMetadataKind = Object.freeze({
|
|
999
|
-
PiCustomData:
|
|
1000
|
-
PiCustomMessageDetails:
|
|
1001
|
-
PiToolResultDetails:
|
|
1002
|
-
PiCompactionDetails:
|
|
1003
|
-
PiBranchSummaryDetails:
|
|
999
|
+
PiCustomData: "pi.custom.data",
|
|
1000
|
+
PiCustomMessageDetails: "pi.custommessage.details",
|
|
1001
|
+
PiToolResultDetails: "pi.toolresult.details",
|
|
1002
|
+
PiCompactionDetails: "pi.compaction.details",
|
|
1003
|
+
PiBranchSummaryDetails: "pi.branchsummary.details",
|
|
1004
1004
|
});
|
|
1005
1005
|
export const AllNativeMetadataKinds = Object.freeze([NativeMetadataKind.PiCustomData, NativeMetadataKind.PiCustomMessageDetails, NativeMetadataKind.PiToolResultDetails, NativeMetadataKind.PiCompactionDetails, NativeMetadataKind.PiBranchSummaryDetails]);
|
|
1006
1006
|
export function isNativeMetadataKind(value) {
|
|
1007
1007
|
return zNativeMetadataKind.safeParse(value).success;
|
|
1008
1008
|
}
|
|
1009
1009
|
export const NativeMetadataSourceType = Object.freeze({
|
|
1010
|
-
PiCustom:
|
|
1011
|
-
PiCustomMessage:
|
|
1012
|
-
PiMessage:
|
|
1013
|
-
PiCompaction:
|
|
1014
|
-
PiBranchSummary:
|
|
1010
|
+
PiCustom: "pi.custom",
|
|
1011
|
+
PiCustomMessage: "pi.custom_message",
|
|
1012
|
+
PiMessage: "pi.message",
|
|
1013
|
+
PiCompaction: "pi.compaction",
|
|
1014
|
+
PiBranchSummary: "pi.branch_summary",
|
|
1015
1015
|
});
|
|
1016
1016
|
export const AllNativeMetadataSourceTypes = Object.freeze([NativeMetadataSourceType.PiCustom, NativeMetadataSourceType.PiCustomMessage, NativeMetadataSourceType.PiMessage, NativeMetadataSourceType.PiCompaction, NativeMetadataSourceType.PiBranchSummary]);
|
|
1017
1017
|
export function isNativeMetadataSourceType(value) {
|
|
1018
1018
|
return zNativeMetadataSourceType.safeParse(value).success;
|
|
1019
1019
|
}
|
|
1020
1020
|
export const NativePiMessageRole = Object.freeze({
|
|
1021
|
-
ToolResult:
|
|
1021
|
+
ToolResult: "toolResult",
|
|
1022
1022
|
});
|
|
1023
1023
|
export const AllNativePiMessageRoles = Object.freeze([NativePiMessageRole.ToolResult]);
|
|
1024
1024
|
export function isNativePiMessageRole(value) {
|
|
1025
1025
|
return zNativePiMessageRole.safeParse(value).success;
|
|
1026
1026
|
}
|
|
1027
1027
|
export const DigestItemKind = Object.freeze({
|
|
1028
|
-
Session:
|
|
1029
|
-
Prompt:
|
|
1030
|
-
Skill:
|
|
1031
|
-
Commit:
|
|
1028
|
+
Session: "session",
|
|
1029
|
+
Prompt: "prompt",
|
|
1030
|
+
Skill: "skill",
|
|
1031
|
+
Commit: "commit",
|
|
1032
1032
|
});
|
|
1033
1033
|
export const AllDigestItemKinds = Object.freeze([DigestItemKind.Session, DigestItemKind.Prompt, DigestItemKind.Skill, DigestItemKind.Commit]);
|
|
1034
1034
|
export function isDigestItemKind(value) {
|
|
1035
1035
|
return zDigestItemKind.safeParse(value).success;
|
|
1036
1036
|
}
|
|
1037
1037
|
export const VillagePullRequestAttachmentState = Object.freeze({
|
|
1038
|
-
Requested:
|
|
1039
|
-
Waiting:
|
|
1040
|
-
Preview:
|
|
1041
|
-
Attached:
|
|
1042
|
-
Detached:
|
|
1038
|
+
Requested: "requested",
|
|
1039
|
+
Waiting: "waiting",
|
|
1040
|
+
Preview: "preview",
|
|
1041
|
+
Attached: "attached",
|
|
1042
|
+
Detached: "detached",
|
|
1043
1043
|
});
|
|
1044
1044
|
export const AllVillagePullRequestAttachmentStates = Object.freeze([VillagePullRequestAttachmentState.Requested, VillagePullRequestAttachmentState.Waiting, VillagePullRequestAttachmentState.Preview, VillagePullRequestAttachmentState.Attached, VillagePullRequestAttachmentState.Detached]);
|
|
1045
1045
|
export function isVillagePullRequestAttachmentState(value) {
|
|
1046
1046
|
return zVillagePullRequestAttachmentState.safeParse(value).success;
|
|
1047
1047
|
}
|
|
1048
1048
|
export const VillagePromptsCheckMode = Object.freeze({
|
|
1049
|
-
Informational:
|
|
1050
|
-
Required:
|
|
1049
|
+
Informational: "informational",
|
|
1050
|
+
Required: "required",
|
|
1051
1051
|
});
|
|
1052
1052
|
export const AllVillagePromptsCheckModes = Object.freeze([VillagePromptsCheckMode.Informational, VillagePromptsCheckMode.Required]);
|
|
1053
1053
|
export function isVillagePromptsCheckMode(value) {
|
|
1054
1054
|
return zVillagePromptsCheckMode.safeParse(value).success;
|
|
1055
1055
|
}
|
|
1056
1056
|
export const VillagePublicOwnerKind = Object.freeze({
|
|
1057
|
-
Profile:
|
|
1058
|
-
Anonymous:
|
|
1057
|
+
Profile: "profile",
|
|
1058
|
+
Anonymous: "anonymous",
|
|
1059
1059
|
});
|
|
1060
1060
|
export const AllVillagePublicOwnerKinds = Object.freeze([VillagePublicOwnerKind.Profile, VillagePublicOwnerKind.Anonymous]);
|
|
1061
1061
|
export function isVillagePublicOwnerKind(value) {
|
|
1062
1062
|
return zVillagePublicOwnerKind.safeParse(value).success;
|
|
1063
1063
|
}
|
|
1064
1064
|
export const SessionRelationshipKind = Object.freeze({
|
|
1065
|
-
StartedBy:
|
|
1066
|
-
ContextFrom:
|
|
1065
|
+
StartedBy: "started_by",
|
|
1066
|
+
ContextFrom: "context_from",
|
|
1067
1067
|
});
|
|
1068
1068
|
export const AllSessionRelationshipKinds = Object.freeze([SessionRelationshipKind.StartedBy, SessionRelationshipKind.ContextFrom]);
|
|
1069
1069
|
export function isSessionRelationshipKind(value) {
|
|
1070
1070
|
return zSessionRelationshipKind.safeParse(value).success;
|
|
1071
1071
|
}
|
|
1072
1072
|
export const RelationshipTargetState = Object.freeze({
|
|
1073
|
-
Known:
|
|
1074
|
-
KnownRetained:
|
|
1075
|
-
ExplicitNone:
|
|
1076
|
-
Unknown:
|
|
1077
|
-
ConflictingCurrentNativeEvidence:
|
|
1073
|
+
Known: "target_known",
|
|
1074
|
+
KnownRetained: "target_known_retained",
|
|
1075
|
+
ExplicitNone: "explicit_none",
|
|
1076
|
+
Unknown: "unknown",
|
|
1077
|
+
ConflictingCurrentNativeEvidence: "conflicting_current_native_evidence",
|
|
1078
1078
|
});
|
|
1079
1079
|
export const AllRelationshipTargetStates = Object.freeze([RelationshipTargetState.Known, RelationshipTargetState.KnownRetained, RelationshipTargetState.ExplicitNone, RelationshipTargetState.Unknown, RelationshipTargetState.ConflictingCurrentNativeEvidence]);
|
|
1080
1080
|
export function isRelationshipTargetState(value) {
|
|
1081
1081
|
return zRelationshipTargetState.safeParse(value).success;
|
|
1082
1082
|
}
|
|
1083
1083
|
export const EvidenceKind = Object.freeze({
|
|
1084
|
-
NativeTyped:
|
|
1085
|
-
LifecycleTyped:
|
|
1086
|
-
ExistingAdapter:
|
|
1087
|
-
RetainedLastGood:
|
|
1088
|
-
Unknown:
|
|
1089
|
-
Conflict:
|
|
1084
|
+
NativeTyped: "native_typed",
|
|
1085
|
+
LifecycleTyped: "lifecycle_typed",
|
|
1086
|
+
ExistingAdapter: "existing_adapter",
|
|
1087
|
+
RetainedLastGood: "retained_last_good",
|
|
1088
|
+
Unknown: "unknown",
|
|
1089
|
+
Conflict: "conflict",
|
|
1090
1090
|
});
|
|
1091
1091
|
export const AllEvidenceKinds = Object.freeze([EvidenceKind.NativeTyped, EvidenceKind.LifecycleTyped, EvidenceKind.ExistingAdapter, EvidenceKind.RetainedLastGood, EvidenceKind.Unknown, EvidenceKind.Conflict]);
|
|
1092
1092
|
export function isEvidenceKind(value) {
|
|
1093
1093
|
return zEvidenceKind.safeParse(value).success;
|
|
1094
1094
|
}
|
|
1095
1095
|
export const SessionTeammateEvidence = Object.freeze({
|
|
1096
|
-
NativeDynamicWorkflow:
|
|
1096
|
+
NativeDynamicWorkflow: "native_dynamic_workflow",
|
|
1097
1097
|
});
|
|
1098
1098
|
export const AllSessionTeammateEvidences = Object.freeze([SessionTeammateEvidence.NativeDynamicWorkflow]);
|
|
1099
1099
|
export function isSessionTeammateEvidence(value) {
|
|
1100
1100
|
return zSessionTeammateEvidence.safeParse(value).success;
|
|
1101
1101
|
}
|
|
1102
1102
|
export const SessionPurpose = Object.freeze({
|
|
1103
|
-
Interaction:
|
|
1104
|
-
DelegatedWork:
|
|
1105
|
-
HelperReview:
|
|
1106
|
-
Unknown:
|
|
1103
|
+
Interaction: "interaction",
|
|
1104
|
+
DelegatedWork: "delegated_work",
|
|
1105
|
+
HelperReview: "helper_review",
|
|
1106
|
+
Unknown: "unknown",
|
|
1107
1107
|
});
|
|
1108
1108
|
export const AllSessionPurposes = Object.freeze([SessionPurpose.Interaction, SessionPurpose.DelegatedWork, SessionPurpose.HelperReview, SessionPurpose.Unknown]);
|
|
1109
1109
|
export function isSessionPurpose(value) {
|
|
1110
1110
|
return zSessionPurpose.safeParse(value).success;
|
|
1111
1111
|
}
|
|
1112
1112
|
export const ContentOrigin = Object.freeze({
|
|
1113
|
-
SubmittedInput:
|
|
1114
|
-
HarnessContext:
|
|
1115
|
-
AgentOutput:
|
|
1116
|
-
AgentCommunication:
|
|
1117
|
-
ToolActivity:
|
|
1118
|
-
SystemControl:
|
|
1119
|
-
GeneratedSummary:
|
|
1120
|
-
Unknown:
|
|
1113
|
+
SubmittedInput: "submitted_input",
|
|
1114
|
+
HarnessContext: "harness_context",
|
|
1115
|
+
AgentOutput: "agent_output",
|
|
1116
|
+
AgentCommunication: "agent_communication",
|
|
1117
|
+
ToolActivity: "tool_activity",
|
|
1118
|
+
SystemControl: "system_control",
|
|
1119
|
+
GeneratedSummary: "generated_summary",
|
|
1120
|
+
Unknown: "unknown",
|
|
1121
1121
|
});
|
|
1122
1122
|
export const AllContentOrigins = Object.freeze([ContentOrigin.SubmittedInput, ContentOrigin.HarnessContext, ContentOrigin.AgentOutput, ContentOrigin.AgentCommunication, ContentOrigin.ToolActivity, ContentOrigin.SystemControl, ContentOrigin.GeneratedSummary, ContentOrigin.Unknown]);
|
|
1123
1123
|
export function isContentOrigin(value) {
|
|
1124
1124
|
return zContentOrigin.safeParse(value).success;
|
|
1125
1125
|
}
|
|
1126
1126
|
export const ActorOrigin = Object.freeze({
|
|
1127
|
-
Operator:
|
|
1128
|
-
AgentDelegate:
|
|
1129
|
-
Harness:
|
|
1130
|
-
Unknown:
|
|
1127
|
+
Operator: "operator",
|
|
1128
|
+
AgentDelegate: "agent_delegate",
|
|
1129
|
+
Harness: "harness",
|
|
1130
|
+
Unknown: "unknown",
|
|
1131
1131
|
});
|
|
1132
1132
|
export const AllActorOrigins = Object.freeze([ActorOrigin.Operator, ActorOrigin.AgentDelegate, ActorOrigin.Harness, ActorOrigin.Unknown]);
|
|
1133
1133
|
export function isActorOrigin(value) {
|
|
1134
1134
|
return zActorOrigin.safeParse(value).success;
|
|
1135
1135
|
}
|
|
1136
1136
|
export const DeliveryOrigin = Object.freeze({
|
|
1137
|
-
SessionAdmission:
|
|
1138
|
-
GuardianReview:
|
|
1139
|
-
SubagentDelivery:
|
|
1140
|
-
InheritedContext:
|
|
1141
|
-
ToolDelivery:
|
|
1142
|
-
SystemLifecycle:
|
|
1143
|
-
Unknown:
|
|
1137
|
+
SessionAdmission: "session_admission",
|
|
1138
|
+
GuardianReview: "guardian_review",
|
|
1139
|
+
SubagentDelivery: "subagent_delivery",
|
|
1140
|
+
InheritedContext: "inherited_context",
|
|
1141
|
+
ToolDelivery: "tool_delivery",
|
|
1142
|
+
SystemLifecycle: "system_lifecycle",
|
|
1143
|
+
Unknown: "unknown",
|
|
1144
1144
|
});
|
|
1145
1145
|
export const AllDeliveryOrigins = Object.freeze([DeliveryOrigin.SessionAdmission, DeliveryOrigin.GuardianReview, DeliveryOrigin.SubagentDelivery, DeliveryOrigin.InheritedContext, DeliveryOrigin.ToolDelivery, DeliveryOrigin.SystemLifecycle, DeliveryOrigin.Unknown]);
|
|
1146
1146
|
export function isDeliveryOrigin(value) {
|
|
1147
1147
|
return zDeliveryOrigin.safeParse(value).success;
|
|
1148
1148
|
}
|
|
1149
1149
|
export const ContentOwnership = Object.freeze({
|
|
1150
|
-
Local:
|
|
1151
|
-
Inherited:
|
|
1152
|
-
Uncertain:
|
|
1150
|
+
Local: "local",
|
|
1151
|
+
Inherited: "inherited",
|
|
1152
|
+
Uncertain: "uncertain",
|
|
1153
1153
|
});
|
|
1154
1154
|
export const AllContentOwnerships = Object.freeze([ContentOwnership.Local, ContentOwnership.Inherited, ContentOwnership.Uncertain]);
|
|
1155
1155
|
export function isContentOwnership(value) {
|
|
1156
1156
|
return zContentOwnership.safeParse(value).success;
|
|
1157
1157
|
}
|
|
1158
1158
|
export const InputModality = Object.freeze({
|
|
1159
|
-
None:
|
|
1160
|
-
Text:
|
|
1161
|
-
Media:
|
|
1162
|
-
UserAction:
|
|
1163
|
-
Mixed:
|
|
1164
|
-
Unknown:
|
|
1159
|
+
None: "none",
|
|
1160
|
+
Text: "text",
|
|
1161
|
+
Media: "media",
|
|
1162
|
+
UserAction: "user_action",
|
|
1163
|
+
Mixed: "mixed",
|
|
1164
|
+
Unknown: "unknown",
|
|
1165
1165
|
});
|
|
1166
1166
|
export const AllInputModalities = Object.freeze([InputModality.None, InputModality.Text, InputModality.Media, InputModality.UserAction, InputModality.Mixed, InputModality.Unknown]);
|
|
1167
1167
|
export function isInputModality(value) {
|
|
1168
1168
|
return zInputModality.safeParse(value).success;
|
|
1169
1169
|
}
|
|
1170
1170
|
export const PublicSourceAnchorKind = Object.freeze({
|
|
1171
|
-
General:
|
|
1172
|
-
Before:
|
|
1173
|
-
Through:
|
|
1171
|
+
General: "general_source_session",
|
|
1172
|
+
Before: "before_redacted_entry",
|
|
1173
|
+
Through: "through_redacted_entry",
|
|
1174
1174
|
});
|
|
1175
1175
|
export const AllPublicSourceAnchorKinds = Object.freeze([PublicSourceAnchorKind.General, PublicSourceAnchorKind.Before, PublicSourceAnchorKind.Through]);
|
|
1176
1176
|
export function isPublicSourceAnchorKind(value) {
|
|
1177
1177
|
return zPublicSourceAnchorKind.safeParse(value).success;
|
|
1178
1178
|
}
|
|
1179
1179
|
export const EarlierHistoryState = Object.freeze({
|
|
1180
|
-
UncertainMigrated:
|
|
1181
|
-
UncertainUnresolved:
|
|
1180
|
+
UncertainMigrated: "uncertain_migrated",
|
|
1181
|
+
UncertainUnresolved: "uncertain_unresolved",
|
|
1182
1182
|
});
|
|
1183
1183
|
export const AllEarlierHistoryStates = Object.freeze([EarlierHistoryState.UncertainMigrated, EarlierHistoryState.UncertainUnresolved]);
|
|
1184
1184
|
export function isEarlierHistoryState(value) {
|
|
1185
1185
|
return zEarlierHistoryState.safeParse(value).success;
|
|
1186
1186
|
}
|
|
1187
1187
|
export const RelationshipNavigationStatus = Object.freeze({
|
|
1188
|
-
Resolved:
|
|
1189
|
-
GeneralLinkOnly:
|
|
1190
|
-
KnownUnavailable:
|
|
1191
|
-
Inaccessible:
|
|
1192
|
-
Unknown:
|
|
1193
|
-
Conflicting:
|
|
1188
|
+
Resolved: "resolved",
|
|
1189
|
+
GeneralLinkOnly: "general_link_only",
|
|
1190
|
+
KnownUnavailable: "known_unavailable",
|
|
1191
|
+
Inaccessible: "inaccessible",
|
|
1192
|
+
Unknown: "unknown",
|
|
1193
|
+
Conflicting: "conflicting",
|
|
1194
1194
|
});
|
|
1195
1195
|
export const AllRelationshipNavigationStatuses = Object.freeze([RelationshipNavigationStatus.Resolved, RelationshipNavigationStatus.GeneralLinkOnly, RelationshipNavigationStatus.KnownUnavailable, RelationshipNavigationStatus.Inaccessible, RelationshipNavigationStatus.Unknown, RelationshipNavigationStatus.Conflicting]);
|
|
1196
1196
|
export function isRelationshipNavigationStatus(value) {
|
|
1197
1197
|
return zRelationshipNavigationStatus.safeParse(value).success;
|
|
1198
1198
|
}
|
|
1199
1199
|
export const SessionListItemKind = Object.freeze({
|
|
1200
|
-
Transcript:
|
|
1201
|
-
ContextContainer:
|
|
1200
|
+
Transcript: "transcript",
|
|
1201
|
+
ContextContainer: "context_container",
|
|
1202
1202
|
});
|
|
1203
1203
|
export const AllSessionListItemKinds = Object.freeze([SessionListItemKind.Transcript, SessionListItemKind.ContextContainer]);
|
|
1204
1204
|
export function isSessionListItemKind(value) {
|
|
1205
1205
|
return zSessionListItemKind.safeParse(value).success;
|
|
1206
1206
|
}
|
|
1207
1207
|
export const SyncStatus = Object.freeze({
|
|
1208
|
-
New:
|
|
1209
|
-
Updated:
|
|
1210
|
-
Synced:
|
|
1211
|
-
Held:
|
|
1208
|
+
New: "new",
|
|
1209
|
+
Updated: "updated",
|
|
1210
|
+
Synced: "synced",
|
|
1211
|
+
Held: "held",
|
|
1212
1212
|
});
|
|
1213
1213
|
export const AllSyncStatuses = Object.freeze([SyncStatus.New, SyncStatus.Updated, SyncStatus.Synced, SyncStatus.Held]);
|
|
1214
1214
|
export function isSyncStatus(value) {
|
|
1215
1215
|
return zSyncStatus.safeParse(value).success;
|
|
1216
1216
|
}
|
|
1217
1217
|
export const SyncHoldReason = Object.freeze({
|
|
1218
|
-
MetricsMissing:
|
|
1219
|
-
MetadataMissing:
|
|
1218
|
+
MetricsMissing: "metrics_missing",
|
|
1219
|
+
MetadataMissing: "metadata_missing",
|
|
1220
1220
|
});
|
|
1221
1221
|
export const AllSyncHoldReasons = Object.freeze([SyncHoldReason.MetricsMissing, SyncHoldReason.MetadataMissing]);
|
|
1222
1222
|
export function isSyncHoldReason(value) {
|
|
1223
1223
|
return zSyncHoldReason.safeParse(value).success;
|
|
1224
1224
|
}
|
|
1225
1225
|
export const SyncPushSessionStatus = Object.freeze({
|
|
1226
|
-
New:
|
|
1227
|
-
Updated:
|
|
1228
|
-
Skipped:
|
|
1229
|
-
Error:
|
|
1230
|
-
Held:
|
|
1226
|
+
New: "new",
|
|
1227
|
+
Updated: "updated",
|
|
1228
|
+
Skipped: "skipped",
|
|
1229
|
+
Error: "error",
|
|
1230
|
+
Held: "held",
|
|
1231
1231
|
});
|
|
1232
1232
|
export const AllSyncPushSessionStatuses = Object.freeze([SyncPushSessionStatus.New, SyncPushSessionStatus.Updated, SyncPushSessionStatus.Skipped, SyncPushSessionStatus.Error, SyncPushSessionStatus.Held]);
|
|
1233
1233
|
export function isSyncPushSessionStatus(value) {
|
|
1234
1234
|
return zSyncPushSessionStatus.safeParse(value).success;
|
|
1235
1235
|
}
|
|
1236
1236
|
export const SyncPushStep = Object.freeze({
|
|
1237
|
-
Content:
|
|
1238
|
-
AddCollective:
|
|
1239
|
-
RemoveCollective:
|
|
1237
|
+
Content: "content",
|
|
1238
|
+
AddCollective: "add_collective",
|
|
1239
|
+
RemoveCollective: "remove_collective",
|
|
1240
1240
|
});
|
|
1241
1241
|
export const AllSyncPushSteps = Object.freeze([SyncPushStep.Content, SyncPushStep.AddCollective, SyncPushStep.RemoveCollective]);
|
|
1242
1242
|
export function isSyncPushStep(value) {
|
|
1243
1243
|
return zSyncPushStep.safeParse(value).success;
|
|
1244
1244
|
}
|
|
1245
1245
|
export const SyncPushStepOutcome = Object.freeze({
|
|
1246
|
-
Succeeded:
|
|
1247
|
-
PendingApproval:
|
|
1248
|
-
Skipped:
|
|
1249
|
-
Failed:
|
|
1250
|
-
NotAttempted:
|
|
1246
|
+
Succeeded: "succeeded",
|
|
1247
|
+
PendingApproval: "pending_approval",
|
|
1248
|
+
Skipped: "skipped",
|
|
1249
|
+
Failed: "failed",
|
|
1250
|
+
NotAttempted: "not_attempted",
|
|
1251
1251
|
});
|
|
1252
1252
|
export const AllSyncPushStepOutcomes = Object.freeze([SyncPushStepOutcome.Succeeded, SyncPushStepOutcome.PendingApproval, SyncPushStepOutcome.Skipped, SyncPushStepOutcome.Failed, SyncPushStepOutcome.NotAttempted]);
|
|
1253
1253
|
export function isSyncPushStepOutcome(value) {
|
|
1254
1254
|
return zSyncPushStepOutcome.safeParse(value).success;
|
|
1255
1255
|
}
|
|
1256
1256
|
export const SyncLoginStatus = Object.freeze({
|
|
1257
|
-
Pending:
|
|
1258
|
-
AlreadyAuthenticated:
|
|
1257
|
+
Pending: "pending",
|
|
1258
|
+
AlreadyAuthenticated: "already_authenticated",
|
|
1259
1259
|
});
|
|
1260
1260
|
export const AllSyncLoginStatuses = Object.freeze([SyncLoginStatus.Pending, SyncLoginStatus.AlreadyAuthenticated]);
|
|
1261
1261
|
export function isSyncLoginStatus(value) {
|
|
1262
1262
|
return zSyncLoginStatus.safeParse(value).success;
|
|
1263
1263
|
}
|
|
1264
1264
|
export const SyncLogoutStatus = Object.freeze({
|
|
1265
|
-
LoggedOut:
|
|
1266
|
-
AlreadyLoggedOut:
|
|
1265
|
+
LoggedOut: "logged_out",
|
|
1266
|
+
AlreadyLoggedOut: "already_logged_out",
|
|
1267
1267
|
});
|
|
1268
1268
|
export const AllSyncLogoutStatuses = Object.freeze([SyncLogoutStatus.LoggedOut, SyncLogoutStatus.AlreadyLoggedOut]);
|
|
1269
1269
|
export function isSyncLogoutStatus(value) {
|
|
1270
1270
|
return zSyncLogoutStatus.safeParse(value).success;
|
|
1271
1271
|
}
|
|
1272
1272
|
export const LocalPublicationState = Object.freeze({
|
|
1273
|
-
Unpublished:
|
|
1274
|
-
Published:
|
|
1273
|
+
Unpublished: "unpublished",
|
|
1274
|
+
Published: "published",
|
|
1275
1275
|
});
|
|
1276
1276
|
export const AllLocalPublicationStates = Object.freeze([LocalPublicationState.Unpublished, LocalPublicationState.Published]);
|
|
1277
1277
|
export function isLocalPublicationState(value) {
|
|
1278
1278
|
return zLocalPublicationState.safeParse(value).success;
|
|
1279
1279
|
}
|
|
1280
1280
|
export const LocalCollectiveSuggestionReason = Object.freeze({
|
|
1281
|
-
LinkedRepository:
|
|
1282
|
-
LinkedGithubOrg:
|
|
1281
|
+
LinkedRepository: "linked_repository",
|
|
1282
|
+
LinkedGithubOrg: "linked_github_org",
|
|
1283
1283
|
});
|
|
1284
1284
|
export const AllLocalCollectiveSuggestionReasons = Object.freeze([LocalCollectiveSuggestionReason.LinkedRepository, LocalCollectiveSuggestionReason.LinkedGithubOrg]);
|
|
1285
1285
|
export function isLocalCollectiveSuggestionReason(value) {
|
|
1286
1286
|
return zLocalCollectiveSuggestionReason.safeParse(value).success;
|
|
1287
1287
|
}
|
|
1288
1288
|
export const LocalSettingKind = Object.freeze({
|
|
1289
|
-
Boolean:
|
|
1290
|
-
Integer:
|
|
1291
|
-
String:
|
|
1292
|
-
StringList:
|
|
1293
|
-
Choice:
|
|
1294
|
-
Structured:
|
|
1289
|
+
Boolean: "boolean",
|
|
1290
|
+
Integer: "integer",
|
|
1291
|
+
String: "string",
|
|
1292
|
+
StringList: "string_list",
|
|
1293
|
+
Choice: "choice",
|
|
1294
|
+
Structured: "structured",
|
|
1295
1295
|
});
|
|
1296
1296
|
export const AllLocalSettingKinds = Object.freeze([LocalSettingKind.Boolean, LocalSettingKind.Integer, LocalSettingKind.String, LocalSettingKind.StringList, LocalSettingKind.Choice, LocalSettingKind.Structured]);
|
|
1297
1297
|
export function isLocalSettingKind(value) {
|
|
1298
1298
|
return zLocalSettingKind.safeParse(value).success;
|
|
1299
1299
|
}
|
|
1300
1300
|
export const LocalKickstartScope = Object.freeze({
|
|
1301
|
-
Full:
|
|
1302
|
-
Selection:
|
|
1301
|
+
Full: "full",
|
|
1302
|
+
Selection: "selection",
|
|
1303
1303
|
});
|
|
1304
1304
|
export const AllLocalKickstartScopes = Object.freeze([LocalKickstartScope.Full, LocalKickstartScope.Selection]);
|
|
1305
1305
|
export function isLocalKickstartScope(value) {
|
|
1306
1306
|
return zLocalKickstartScope.safeParse(value).success;
|
|
1307
1307
|
}
|
|
1308
1308
|
export const LocalKickstartStopKind = Object.freeze({
|
|
1309
|
-
Connection:
|
|
1310
|
-
Config:
|
|
1311
|
-
Review:
|
|
1312
|
-
Ingest:
|
|
1309
|
+
Connection: "connection",
|
|
1310
|
+
Config: "config",
|
|
1311
|
+
Review: "review",
|
|
1312
|
+
Ingest: "ingest",
|
|
1313
1313
|
});
|
|
1314
1314
|
export const AllLocalKickstartStopKinds = Object.freeze([LocalKickstartStopKind.Connection, LocalKickstartStopKind.Config, LocalKickstartStopKind.Review, LocalKickstartStopKind.Ingest]);
|
|
1315
1315
|
export function isLocalKickstartStopKind(value) {
|
|
1316
1316
|
return zLocalKickstartStopKind.safeParse(value).success;
|
|
1317
1317
|
}
|
|
1318
1318
|
export const LocalKickstartFieldKind = Object.freeze({
|
|
1319
|
-
Toggle:
|
|
1320
|
-
Choice:
|
|
1321
|
-
Action:
|
|
1322
|
-
Tree:
|
|
1323
|
-
Notice:
|
|
1319
|
+
Toggle: "toggle",
|
|
1320
|
+
Choice: "choice",
|
|
1321
|
+
Action: "action",
|
|
1322
|
+
Tree: "tree",
|
|
1323
|
+
Notice: "notice",
|
|
1324
1324
|
});
|
|
1325
1325
|
export const AllLocalKickstartFieldKinds = Object.freeze([LocalKickstartFieldKind.Toggle, LocalKickstartFieldKind.Choice, LocalKickstartFieldKind.Action, LocalKickstartFieldKind.Tree, LocalKickstartFieldKind.Notice]);
|
|
1326
1326
|
export function isLocalKickstartFieldKind(value) {
|
|
1327
1327
|
return zLocalKickstartFieldKind.safeParse(value).success;
|
|
1328
1328
|
}
|
|
1329
1329
|
export const LocalKickstartLineKind = Object.freeze({
|
|
1330
|
-
Text:
|
|
1331
|
-
Label:
|
|
1332
|
-
Before:
|
|
1333
|
-
After:
|
|
1334
|
-
Spacer:
|
|
1330
|
+
Text: "text",
|
|
1331
|
+
Label: "label",
|
|
1332
|
+
Before: "before",
|
|
1333
|
+
After: "after",
|
|
1334
|
+
Spacer: "spacer",
|
|
1335
1335
|
});
|
|
1336
1336
|
export const AllLocalKickstartLineKinds = Object.freeze([LocalKickstartLineKind.Text, LocalKickstartLineKind.Label, LocalKickstartLineKind.Before, LocalKickstartLineKind.After, LocalKickstartLineKind.Spacer]);
|
|
1337
1337
|
export function isLocalKickstartLineKind(value) {
|
|
1338
1338
|
return zLocalKickstartLineKind.safeParse(value).success;
|
|
1339
1339
|
}
|
|
1340
1340
|
export const LocalKickstartNodeKind = Object.freeze({
|
|
1341
|
-
Project:
|
|
1342
|
-
Group:
|
|
1343
|
-
Branch:
|
|
1344
|
-
Session:
|
|
1341
|
+
Project: "project",
|
|
1342
|
+
Group: "group",
|
|
1343
|
+
Branch: "branch",
|
|
1344
|
+
Session: "session",
|
|
1345
1345
|
});
|
|
1346
1346
|
export const AllLocalKickstartNodeKinds = Object.freeze([LocalKickstartNodeKind.Project, LocalKickstartNodeKind.Group, LocalKickstartNodeKind.Branch, LocalKickstartNodeKind.Session]);
|
|
1347
1347
|
export function isLocalKickstartNodeKind(value) {
|
|
1348
1348
|
return zLocalKickstartNodeKind.safeParse(value).success;
|
|
1349
1349
|
}
|
|
1350
1350
|
export const LocalKickstartNodeState = Object.freeze({
|
|
1351
|
-
None:
|
|
1352
|
-
Some:
|
|
1353
|
-
All:
|
|
1351
|
+
None: "none",
|
|
1352
|
+
Some: "some",
|
|
1353
|
+
All: "all",
|
|
1354
1354
|
});
|
|
1355
1355
|
export const AllLocalKickstartNodeStates = Object.freeze([LocalKickstartNodeState.None, LocalKickstartNodeState.Some, LocalKickstartNodeState.All]);
|
|
1356
1356
|
export function isLocalKickstartNodeState(value) {
|
|
1357
1357
|
return zLocalKickstartNodeState.safeParse(value).success;
|
|
1358
1358
|
}
|
|
1359
1359
|
export const LocalKickstartScanState = Object.freeze({
|
|
1360
|
-
Idle:
|
|
1361
|
-
Running:
|
|
1362
|
-
Done:
|
|
1363
|
-
Error:
|
|
1360
|
+
Idle: "idle",
|
|
1361
|
+
Running: "running",
|
|
1362
|
+
Done: "done",
|
|
1363
|
+
Error: "error",
|
|
1364
1364
|
});
|
|
1365
1365
|
export const AllLocalKickstartScanStates = Object.freeze([LocalKickstartScanState.Idle, LocalKickstartScanState.Running, LocalKickstartScanState.Done, LocalKickstartScanState.Error]);
|
|
1366
1366
|
export function isLocalKickstartScanState(value) {
|
|
1367
1367
|
return zLocalKickstartScanState.safeParse(value).success;
|
|
1368
1368
|
}
|
|
1369
1369
|
export const LocalKickstartIngestState = Object.freeze({
|
|
1370
|
-
Idle:
|
|
1371
|
-
Running:
|
|
1372
|
-
Busy:
|
|
1373
|
-
Failed:
|
|
1370
|
+
Idle: "idle",
|
|
1371
|
+
Running: "running",
|
|
1372
|
+
Busy: "busy",
|
|
1373
|
+
Failed: "failed",
|
|
1374
1374
|
});
|
|
1375
1375
|
export const AllLocalKickstartIngestStates = Object.freeze([LocalKickstartIngestState.Idle, LocalKickstartIngestState.Running, LocalKickstartIngestState.Busy, LocalKickstartIngestState.Failed]);
|
|
1376
1376
|
export function isLocalKickstartIngestState(value) {
|
|
1377
1377
|
return zLocalKickstartIngestState.safeParse(value).success;
|
|
1378
1378
|
}
|
|
1379
1379
|
export const LocalKickstartResolution = Object.freeze({
|
|
1380
|
-
Mine:
|
|
1381
|
-
Theirs:
|
|
1380
|
+
Mine: "mine",
|
|
1381
|
+
Theirs: "theirs",
|
|
1382
1382
|
});
|
|
1383
1383
|
export const AllLocalKickstartResolutions = Object.freeze([LocalKickstartResolution.Mine, LocalKickstartResolution.Theirs]);
|
|
1384
1384
|
export function isLocalKickstartResolution(value) {
|
|
1385
1385
|
return zLocalKickstartResolution.safeParse(value).success;
|
|
1386
1386
|
}
|
|
1387
1387
|
export const LocalKickstartNextStep = Object.freeze({
|
|
1388
|
-
Config:
|
|
1389
|
-
WebStart:
|
|
1390
|
-
VillageLogin:
|
|
1391
|
-
VillagePush:
|
|
1392
|
-
AutoPublish:
|
|
1388
|
+
Config: "config",
|
|
1389
|
+
WebStart: "web-start",
|
|
1390
|
+
VillageLogin: "village-login",
|
|
1391
|
+
VillagePush: "village-push",
|
|
1392
|
+
AutoPublish: "auto-publish-settings",
|
|
1393
1393
|
});
|
|
1394
1394
|
export const AllLocalKickstartNextSteps = Object.freeze([LocalKickstartNextStep.Config, LocalKickstartNextStep.WebStart, LocalKickstartNextStep.VillageLogin, LocalKickstartNextStep.VillagePush, LocalKickstartNextStep.AutoPublish]);
|
|
1395
1395
|
export function isLocalKickstartNextStep(value) {
|
|
1396
1396
|
return zLocalKickstartNextStep.safeParse(value).success;
|
|
1397
1397
|
}
|
|
1398
1398
|
export const LocalKickstartDiffLineType = Object.freeze({
|
|
1399
|
-
Add:
|
|
1400
|
-
Del:
|
|
1401
|
-
Ctx:
|
|
1399
|
+
Add: "add",
|
|
1400
|
+
Del: "del",
|
|
1401
|
+
Ctx: "ctx",
|
|
1402
1402
|
});
|
|
1403
1403
|
export const AllLocalKickstartDiffLineTypes = Object.freeze([LocalKickstartDiffLineType.Add, LocalKickstartDiffLineType.Del, LocalKickstartDiffLineType.Ctx]);
|
|
1404
1404
|
export function isLocalKickstartDiffLineType(value) {
|
|
1405
1405
|
return zLocalKickstartDiffLineType.safeParse(value).success;
|
|
1406
1406
|
}
|
|
1407
1407
|
export const LocalKickstartEventKind = Object.freeze({
|
|
1408
|
-
Session:
|
|
1409
|
-
Answers:
|
|
1410
|
-
Conflicts:
|
|
1411
|
-
Scan:
|
|
1412
|
-
Ingest:
|
|
1413
|
-
Closed:
|
|
1408
|
+
Session: "session",
|
|
1409
|
+
Answers: "answers",
|
|
1410
|
+
Conflicts: "conflicts",
|
|
1411
|
+
Scan: "scan",
|
|
1412
|
+
Ingest: "ingest",
|
|
1413
|
+
Closed: "closed",
|
|
1414
1414
|
});
|
|
1415
1415
|
export const AllLocalKickstartEventKinds = Object.freeze([LocalKickstartEventKind.Session, LocalKickstartEventKind.Answers, LocalKickstartEventKind.Conflicts, LocalKickstartEventKind.Scan, LocalKickstartEventKind.Ingest, LocalKickstartEventKind.Closed]);
|
|
1416
1416
|
export function isLocalKickstartEventKind(value) {
|
|
1417
1417
|
return zLocalKickstartEventKind.safeParse(value).success;
|
|
1418
1418
|
}
|
|
1419
1419
|
export const LocalKickstartCloseReason = Object.freeze({
|
|
1420
|
-
Committed:
|
|
1421
|
-
Expired:
|
|
1420
|
+
Committed: "committed",
|
|
1421
|
+
Expired: "expired",
|
|
1422
1422
|
});
|
|
1423
1423
|
export const AllLocalKickstartCloseReasons = Object.freeze([LocalKickstartCloseReason.Committed, LocalKickstartCloseReason.Expired]);
|
|
1424
1424
|
export function isLocalKickstartCloseReason(value) {
|
|
1425
1425
|
return zLocalKickstartCloseReason.safeParse(value).success;
|
|
1426
1426
|
}
|
|
1427
1427
|
export const LocalKickstartConnectAnswer = Object.freeze({
|
|
1428
|
-
Accept:
|
|
1429
|
-
Skip:
|
|
1428
|
+
Accept: "accept",
|
|
1429
|
+
Skip: "skip",
|
|
1430
1430
|
});
|
|
1431
1431
|
export const AllLocalKickstartConnectAnswers = Object.freeze([LocalKickstartConnectAnswer.Accept, LocalKickstartConnectAnswer.Skip]);
|
|
1432
1432
|
export function isLocalKickstartConnectAnswer(value) {
|
|
1433
1433
|
return zLocalKickstartConnectAnswer.safeParse(value).success;
|
|
1434
1434
|
}
|
|
1435
1435
|
export const LocalKickstartErrorCode = Object.freeze({
|
|
1436
|
-
BodyMissing:
|
|
1437
|
-
BodyInvalid:
|
|
1438
|
-
ScopeInvalid:
|
|
1439
|
-
AnswersInvalid:
|
|
1440
|
-
SessionCommitting:
|
|
1441
|
-
RevisionAhead:
|
|
1442
|
-
AnswerRefused:
|
|
1443
|
-
ScanNotDone:
|
|
1444
|
-
FieldUnknown:
|
|
1445
|
-
FieldOutOfScope:
|
|
1446
|
-
FieldHidden:
|
|
1447
|
-
TreeAnswerShape:
|
|
1448
|
-
ConnectOutOfScope:
|
|
1449
|
-
ConnectNotConnected:
|
|
1450
|
-
ConnectUnknown:
|
|
1451
|
-
CommitRefused:
|
|
1452
|
-
SessionNotFound:
|
|
1453
|
-
PreviewRowNotFound:
|
|
1454
|
-
Failed:
|
|
1455
|
-
StatusUnreadable:
|
|
1456
|
-
ConfigUnreadable:
|
|
1457
|
-
ConfigUnwritable:
|
|
1458
|
-
SessionUnbuildable:
|
|
1459
|
-
AnswerUnencodable:
|
|
1460
|
-
PreviewUnreadable:
|
|
1461
|
-
ContractBreach:
|
|
1462
|
-
Unavailable:
|
|
1463
|
-
ConfigBusy:
|
|
1464
|
-
ConfigChanging:
|
|
1436
|
+
BodyMissing: "kickstart_body_missing",
|
|
1437
|
+
BodyInvalid: "kickstart_body_invalid",
|
|
1438
|
+
ScopeInvalid: "kickstart_scope_invalid",
|
|
1439
|
+
AnswersInvalid: "kickstart_answers_invalid",
|
|
1440
|
+
SessionCommitting: "kickstart_session_committing",
|
|
1441
|
+
RevisionAhead: "kickstart_revision_ahead",
|
|
1442
|
+
AnswerRefused: "kickstart_answer_refused",
|
|
1443
|
+
ScanNotDone: "kickstart_scan_not_done",
|
|
1444
|
+
FieldUnknown: "kickstart_field_unknown",
|
|
1445
|
+
FieldOutOfScope: "kickstart_field_out_of_scope",
|
|
1446
|
+
FieldHidden: "kickstart_field_hidden",
|
|
1447
|
+
TreeAnswerShape: "kickstart_tree_answer_shape",
|
|
1448
|
+
ConnectOutOfScope: "kickstart_connect_out_of_scope",
|
|
1449
|
+
ConnectNotConnected: "kickstart_connect_not_connected",
|
|
1450
|
+
ConnectUnknown: "kickstart_connect_unknown",
|
|
1451
|
+
CommitRefused: "kickstart_commit_refused",
|
|
1452
|
+
SessionNotFound: "kickstart_session_not_found",
|
|
1453
|
+
PreviewRowNotFound: "kickstart_preview_row_not_found",
|
|
1454
|
+
Failed: "kickstart_failed",
|
|
1455
|
+
StatusUnreadable: "kickstart_status_unreadable",
|
|
1456
|
+
ConfigUnreadable: "kickstart_config_unreadable",
|
|
1457
|
+
ConfigUnwritable: "kickstart_config_unwritable",
|
|
1458
|
+
SessionUnbuildable: "kickstart_session_unbuildable",
|
|
1459
|
+
AnswerUnencodable: "kickstart_answer_unencodable",
|
|
1460
|
+
PreviewUnreadable: "kickstart_preview_unreadable",
|
|
1461
|
+
ContractBreach: "publishing_contract_breach",
|
|
1462
|
+
Unavailable: "kickstart_unavailable",
|
|
1463
|
+
ConfigBusy: "kickstart_config_busy",
|
|
1464
|
+
ConfigChanging: "kickstart_config_changing",
|
|
1465
1465
|
});
|
|
1466
1466
|
export const AllLocalKickstartErrorCodes = Object.freeze([LocalKickstartErrorCode.BodyMissing, LocalKickstartErrorCode.BodyInvalid, LocalKickstartErrorCode.ScopeInvalid, LocalKickstartErrorCode.AnswersInvalid, LocalKickstartErrorCode.SessionCommitting, LocalKickstartErrorCode.RevisionAhead, LocalKickstartErrorCode.AnswerRefused, LocalKickstartErrorCode.ScanNotDone, LocalKickstartErrorCode.FieldUnknown, LocalKickstartErrorCode.FieldOutOfScope, LocalKickstartErrorCode.FieldHidden, LocalKickstartErrorCode.TreeAnswerShape, LocalKickstartErrorCode.ConnectOutOfScope, LocalKickstartErrorCode.ConnectNotConnected, LocalKickstartErrorCode.ConnectUnknown, LocalKickstartErrorCode.CommitRefused, LocalKickstartErrorCode.SessionNotFound, LocalKickstartErrorCode.PreviewRowNotFound, LocalKickstartErrorCode.Failed, LocalKickstartErrorCode.StatusUnreadable, LocalKickstartErrorCode.ConfigUnreadable, LocalKickstartErrorCode.ConfigUnwritable, LocalKickstartErrorCode.SessionUnbuildable, LocalKickstartErrorCode.AnswerUnencodable, LocalKickstartErrorCode.PreviewUnreadable, LocalKickstartErrorCode.ContractBreach, LocalKickstartErrorCode.Unavailable, LocalKickstartErrorCode.ConfigBusy, LocalKickstartErrorCode.ConfigChanging]);
|
|
1467
1467
|
export function isLocalKickstartErrorCode(value) {
|
|
1468
1468
|
return zLocalKickstartErrorCode.safeParse(value).success;
|
|
1469
1469
|
}
|
|
1470
1470
|
export const AutoPublishEvent = Object.freeze({
|
|
1471
|
-
PrePush:
|
|
1472
|
-
PostCommit:
|
|
1471
|
+
PrePush: "pre-push",
|
|
1472
|
+
PostCommit: "post-commit",
|
|
1473
1473
|
});
|
|
1474
1474
|
export const AllAutoPublishEvents = Object.freeze([AutoPublishEvent.PrePush, AutoPublishEvent.PostCommit]);
|
|
1475
1475
|
export function isAutoPublishEvent(value) {
|
|
1476
1476
|
return zAutoPublishEvent.safeParse(value).success;
|
|
1477
1477
|
}
|
|
1478
1478
|
export const AutoPublishHookStatus = Object.freeze({
|
|
1479
|
-
Absent:
|
|
1480
|
-
Installed:
|
|
1481
|
-
Blocked:
|
|
1482
|
-
Failed:
|
|
1479
|
+
Absent: "absent",
|
|
1480
|
+
Installed: "installed",
|
|
1481
|
+
Blocked: "blocked",
|
|
1482
|
+
Failed: "failed",
|
|
1483
1483
|
});
|
|
1484
1484
|
export const AllAutoPublishHookStatuses = Object.freeze([AutoPublishHookStatus.Absent, AutoPublishHookStatus.Installed, AutoPublishHookStatus.Blocked, AutoPublishHookStatus.Failed]);
|
|
1485
1485
|
export function isAutoPublishHookStatus(value) {
|
|
1486
1486
|
return zAutoPublishHookStatus.safeParse(value).success;
|
|
1487
1487
|
}
|
|
1488
1488
|
export const AutoPublishRuleKind = Object.freeze({
|
|
1489
|
-
Folder:
|
|
1490
|
-
Remote:
|
|
1489
|
+
Folder: "folder",
|
|
1490
|
+
Remote: "remote",
|
|
1491
1491
|
});
|
|
1492
1492
|
export const AllAutoPublishRuleKinds = Object.freeze([AutoPublishRuleKind.Folder, AutoPublishRuleKind.Remote]);
|
|
1493
1493
|
export function isAutoPublishRuleKind(value) {
|
|
1494
1494
|
return zAutoPublishRuleKind.safeParse(value).success;
|
|
1495
1495
|
}
|
|
1496
1496
|
export const ThinkingLevel = Object.freeze({
|
|
1497
|
-
Off:
|
|
1498
|
-
Minimal:
|
|
1499
|
-
Low:
|
|
1500
|
-
Medium:
|
|
1501
|
-
High:
|
|
1502
|
-
XHigh:
|
|
1503
|
-
Max:
|
|
1504
|
-
Ultra:
|
|
1505
|
-
Ultracode:
|
|
1497
|
+
Off: "off",
|
|
1498
|
+
Minimal: "minimal",
|
|
1499
|
+
Low: "low",
|
|
1500
|
+
Medium: "medium",
|
|
1501
|
+
High: "high",
|
|
1502
|
+
XHigh: "xhigh",
|
|
1503
|
+
Max: "max",
|
|
1504
|
+
Ultra: "ultra",
|
|
1505
|
+
Ultracode: "ultracode",
|
|
1506
1506
|
});
|
|
1507
1507
|
export const AllThinkingLevels = Object.freeze([ThinkingLevel.Off, ThinkingLevel.Minimal, ThinkingLevel.Low, ThinkingLevel.Medium, ThinkingLevel.High, ThinkingLevel.XHigh, ThinkingLevel.Max, ThinkingLevel.Ultra, ThinkingLevel.Ultracode]);
|
|
1508
1508
|
export function isThinkingLevel(value) {
|
|
1509
1509
|
return zThinkingLevel.safeParse(value).success;
|
|
1510
1510
|
}
|
|
1511
1511
|
export const ScryVerdict = Object.freeze({
|
|
1512
|
-
Checked:
|
|
1513
|
-
Unchecked:
|
|
1512
|
+
Checked: "checked",
|
|
1513
|
+
Unchecked: "unchecked",
|
|
1514
1514
|
});
|
|
1515
1515
|
export const AllScryVerdicts = Object.freeze([ScryVerdict.Checked, ScryVerdict.Unchecked]);
|
|
1516
1516
|
export function isScryVerdict(value) {
|