@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.
@@ -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: zTranscriptEntryReferenceKind.parse("source"),
141
- ToolCall: zTranscriptEntryReferenceKind.parse("tool_call"),
142
- ToolResult: zTranscriptEntryReferenceKind.parse("tool_result"),
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: zTranscriptReadTransportKind.parse("local_session"),
150
- VillageTranscript: zTranscriptReadTransportKind.parse("village_transcript"),
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: zTranscriptRecordedIndexState.parse("present"),
158
- Absent: zTranscriptRecordedIndexState.parse("absent"),
159
- Invalid: zTranscriptRecordedIndexState.parse("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: zTranscriptRetainedState.parse("absent"),
167
- Deferred: zTranscriptRetainedState.parse("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: zTranscriptViewerProjection.parse("anonymous"),
175
- Authenticated: zTranscriptViewerProjection.parse("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: zTranscriptReadValidation.parse("published_strict"),
183
- ServedLegacy: zTranscriptReadValidation.parse("served_legacy"),
184
- Migrated: zTranscriptReadValidation.parse("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: zTranscriptNativePresence.parse("absent"),
192
- Present: zTranscriptNativePresence.parse("present"),
193
- Withheld: zTranscriptNativePresence.parse("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: zTranscriptUsagePresence.parse("present"),
201
- Empty: zTranscriptUsagePresence.parse("empty"),
202
- Unknown: zTranscriptUsagePresence.parse("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: zTranscriptSegmentPartitionKind.parse("main"),
210
- History: zTranscriptSegmentPartitionKind.parse("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: zCollectiveObservationReason.parse("membership"),
218
- Contribution: zCollectiveObservationReason.parse("contribution"),
219
- Organization: zCollectiveObservationReason.parse("organization"),
220
- Explicit: zCollectiveObservationReason.parse("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: zCollectiveObservationState.parse("observed"),
228
- Unavailable: zCollectiveObservationState.parse("unavailable"),
229
- Invalidated: zCollectiveObservationState.parse("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: zCollectiveOperation.parse("publish"),
237
- Share: zCollectiveOperation.parse("share"),
238
- Fetch: zCollectiveOperation.parse("fetch"),
239
- Pull: zCollectiveOperation.parse("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: zOperationIssueCode.parse("auth"),
247
- Remote: zOperationIssueCode.parse("remote"),
248
- Contract: zOperationIssueCode.parse("contract"),
249
- Deadline: zOperationIssueCode.parse("deadline"),
250
- Persistence: zOperationIssueCode.parse("persistence"),
251
- Superseded: zOperationIssueCode.parse("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: zLocalContributionEvidenceKind.parse("remote-attempts"),
259
- Receipts: zLocalContributionEvidenceKind.parse("receipts"),
260
- OperationDiagnostics: zLocalContributionEvidenceKind.parse("operation-diagnostics"),
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: zCollectiveEvidenceCoverage.parse("available"),
268
- Unknown: zCollectiveEvidenceCoverage.parse("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: zLocalConfirmedContributionOutcome.parse("published"),
276
- Submitted: zLocalConfirmedContributionOutcome.parse("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: zLocalOperationDiagnosticOutcome.parse("failed"),
284
- Uncertain: zLocalOperationDiagnosticOutcome.parse("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: zPullAssociationMetadataState.parse("observed"),
292
- Stale: zPullAssociationMetadataState.parse("stale"),
293
- Unknown: zPullAssociationMetadataState.parse("unknown"),
294
- Invalidated: zPullAssociationMetadataState.parse("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: zCollectiveFetchDomain.parse("catalog"),
302
- History: zCollectiveFetchDomain.parse("history"),
303
- Associations: zCollectiveFetchDomain.parse("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: zCollectiveFetchState.parse("complete"),
311
- Failed: zCollectiveFetchState.parse("failed"),
312
- Cancelled: zCollectiveFetchState.parse("cancelled"),
313
- Superseded: zCollectiveFetchState.parse("superseded"),
314
- NotRequested: zCollectiveFetchState.parse("not_requested"),
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: zCollectiveFetchCommit.parse("updated"),
322
- Unchanged: zCollectiveFetchCommit.parse("unchanged"),
323
- Retained: zCollectiveFetchCommit.parse("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: zCollectiveFetchOutcome.parse("complete"),
331
- Partial: zCollectiveFetchOutcome.parse("partial"),
332
- Failed: zCollectiveFetchOutcome.parse("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: zCollectiveObservationSource.parse("membership"),
340
- ContributionDiscovery: zCollectiveObservationSource.parse("contribution-discovery"),
341
- Organization: zCollectiveObservationSource.parse("organization"),
342
- Explicit: zCollectiveObservationSource.parse("explicit"),
343
- Submissions: zCollectiveObservationSource.parse("submissions"),
344
- Attempts: zCollectiveObservationSource.parse("attempts"),
345
- Associations: zCollectiveObservationSource.parse("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: zCollectiveSourceOutcome.parse("disclosed"),
353
- NotDisclosed: zCollectiveSourceOutcome.parse("not_disclosed"),
354
- Failed: zCollectiveSourceOutcome.parse("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: zLocalSyncPublicationFilter.parse("all"),
362
- NotPublished: zLocalSyncPublicationFilter.parse("not-published"),
363
- Published: zLocalSyncPublicationFilter.parse("published"),
364
- Auto: zLocalSyncPublicationFilter.parse("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: zPageSize.parse(25),
372
- P50: zPageSize.parse(50),
373
- P100: zPageSize.parse(100),
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: zPublishOperationKind.parse("preserve"),
381
- Replace: zPublishOperationKind.parse("replace"),
382
- Append: zPublishOperationKind.parse("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: zVisibilityIntent.parse("private"),
390
- Public: zVisibilityIntent.parse("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: zAnnotationAxis.parse("type"),
398
- Session: zAnnotationAxis.parse("session"),
399
- Project: zAnnotationAxis.parse("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: zAnnotationDatatype.parse("text"),
407
- Integer: zAnnotationDatatype.parse("integer"),
408
- Real: zAnnotationDatatype.parse("real"),
409
- Boolean: zAnnotationDatatype.parse("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: zAnnotationPushStatus.parse("created"),
417
- Updated: zAnnotationPushStatus.parse("updated"),
418
- Skipped: zAnnotationPushStatus.parse("skipped"),
419
- Error: zAnnotationPushStatus.parse("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: zAnnotationStatus.parse("proposed"),
427
- Active: zAnnotationStatus.parse("active"),
428
- Deprecated: zAnnotationStatus.parse("deprecated"),
429
- Retired: zAnnotationStatus.parse("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: zAnnotatorKind.parse("human"),
437
- Agent: zAnnotatorKind.parse("agent"),
438
- Rule: zAnnotatorKind.parse("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: zAssociationConclusion.parse("confirmed"),
446
- Candidate: zAssociationConclusion.parse("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: zAssociationEvidenceKind.parse("recorded_commit"),
454
- TouchedFile: zAssociationEvidenceKind.parse("touched_file"),
455
- BranchMembership: zAssociationEvidenceKind.parse("branch_membership"),
456
- TimeWindow: zAssociationEvidenceKind.parse("time_window"),
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: zBuiltinCommand.parse("exit"),
464
- Compact: zBuiltinCommand.parse("compact"),
465
- Clear: zBuiltinCommand.parse("clear"),
466
- New: zBuiltinCommand.parse("new"),
467
- Model: zBuiltinCommand.parse("model"),
468
- Usage: zBuiltinCommand.parse("usage"),
469
- Cost: zBuiltinCommand.parse("cost"),
470
- Context: zBuiltinCommand.parse("context"),
471
- Plugin: zBuiltinCommand.parse("plugin"),
472
- Permissions: zBuiltinCommand.parse("permissions"),
473
- Login: zBuiltinCommand.parse("login"),
474
- Resume: zBuiltinCommand.parse("resume"),
475
- Plan: zBuiltinCommand.parse("plan"),
476
- Fast: zBuiltinCommand.parse("fast"),
477
- Voice: zBuiltinCommand.parse("voice"),
478
- Todos: zBuiltinCommand.parse("todos"),
479
- ReloadPlugins: zBuiltinCommand.parse("reload-plugins"),
480
- Sandbox: zBuiltinCommand.parse("sandbox"),
481
- Config: zBuiltinCommand.parse("config"),
482
- Statusline: zBuiltinCommand.parse("statusline"),
483
- Upgrade: zBuiltinCommand.parse("upgrade"),
484
- ExtraUsage: zBuiltinCommand.parse("extra-usage"),
485
- RateLimitOptions: zBuiltinCommand.parse("rate-limit-options"),
486
- PrivacySettings: zBuiltinCommand.parse("privacy-settings"),
487
- Help: zBuiltinCommand.parse("help"),
488
- Commands: zBuiltinCommand.parse("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: zChangeBinding.parse("bound"),
496
- Candidate: zChangeBinding.parse("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: zChannelTopic.parse("dashboard"),
504
- Sessions: zChannelTopic.parse("sessions"),
505
- SessionDetail: zChannelTopic.parse("session_detail"),
506
- Trends: zChannelTopic.parse("trends"),
507
- Quality: zChannelTopic.parse("quality"),
508
- Annotations: zChannelTopic.parse("annotations"),
509
- ProjectFamiliarity: zChannelTopic.parse("project_familiarity"),
510
- Kickstart: zChannelTopic.parse("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: zConfidence.parse("high"),
518
- Medium: zConfidence.parse("medium"),
519
- Low: zConfidence.parse("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: zContentKind.parse("session_detail"),
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: zDecayLevel.parse("fresh"),
534
- Fading: zDecayLevel.parse("fading"),
535
- Stale: zDecayLevel.parse("stale"),
536
- Unexplored: zDecayLevel.parse("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: zDiffLineKind.parse("context"),
544
- Add: zDiffLineKind.parse("add"),
545
- Delete: zDiffLineKind.parse("del"),
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: zEdgeViolationKind.parse("cycle"),
553
- WrongWay: zEdgeViolationKind.parse("wrong_way"),
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: zEntryType.parse("text"),
561
- ToolUse: zEntryType.parse("tool_use"),
562
- ToolResult: zEntryType.parse("tool_result"),
563
- Thinking: zEntryType.parse("thinking"),
564
- System: zEntryType.parse("system"),
565
- Error: zEntryType.parse("error"),
566
- Result: zEntryType.parse("result"),
567
- Image: zEntryType.parse("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: zTurnPartType.parse("text"),
575
- Image: zTurnPartType.parse("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: zImageMediaType.parse("image/png"),
583
- Jpeg: zImageMediaType.parse("image/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: zOmittedReason.parse("too_large"),
591
- Unsupported: zOmittedReason.parse("unsupported"),
592
- Missing: zOmittedReason.parse("missing"),
593
- NotPublished: zOmittedReason.parse("not_published"),
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: zFileChangeStatus.parse("M"),
601
- Added: zFileChangeStatus.parse("A"),
602
- Deleted: zFileChangeStatus.parse("D"),
603
- Renamed: zFileChangeStatus.parse("R"),
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: zHarness.parse("claude-code"),
611
- GeminiCLI: zHarness.parse("gemini-cli"),
612
- Codex: zHarness.parse("codex"),
613
- OpenCode: zHarness.parse("opencode"),
614
- Cursor: zHarness.parse("cursor"),
615
- Antigravity: zHarness.parse("antigravity"),
616
- Strike: zHarness.parse("strike"),
617
- Pi: zHarness.parse("pi"),
618
- GrokBuild: zHarness.parse("grok-build"),
619
- DevinDesktop: zHarness.parse("devin-desktop"),
620
- Cline: zHarness.parse("cline"),
621
- Kiro: zHarness.parse("kiro"),
622
- KiroCLI: zHarness.parse("kiro-cli"),
623
- KiroCrew: zHarness.parse("kiro-crew"),
624
- AntigravityCLI: zHarness.parse("antigravity-cli"),
625
- AntigravityIDE: zHarness.parse("antigravity-ide"),
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: zInsightKind.parse("decision"),
639
- Friction: zInsightKind.parse("friction"),
640
- Unusual: zInsightKind.parse("unusual"),
641
- RetryLoop: zInsightKind.parse("retry_loop"),
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: zInsightProvenance.parse("mechanical"),
649
- Mined: zInsightProvenance.parse("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: zInteractionType.parse("mentioned"),
657
- Read: zInteractionType.parse("read"),
658
- Discussed: zInteractionType.parse("discussed"),
659
- Questioned: zInteractionType.parse("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: zLicense.parse("CC0-1.0"),
667
- CCBY: zLicense.parse("CC-BY-4.0"),
668
- CCBYSA: zLicense.parse("CC-BY-SA-4.0"),
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: zMapNodeKind.parse("module"),
676
- Package: zMapNodeKind.parse("package"),
677
- File: zMapNodeKind.parse("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: zMessageType.parse("subscribe"),
685
- Unsubscribe: zMessageType.parse("unsubscribe"),
686
- Dashboard: zMessageType.parse("dashboard"),
687
- Sessions: zMessageType.parse("sessions"),
688
- SessionDetail: zMessageType.parse("session_detail"),
689
- Trends: zMessageType.parse("trends"),
690
- Quality: zMessageType.parse("quality"),
691
- Annotations: zMessageType.parse("annotations"),
692
- ProjectFamiliarity: zMessageType.parse("project_familiarity"),
693
- Connected: zMessageType.parse("connected"),
694
- Error: zMessageType.parse("error"),
695
- Kickstart: zMessageType.parse("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: zReadAttributionState.parse("complete"),
703
- Partial: zReadAttributionState.parse("partial"),
704
- Unavailable: zReadAttributionState.parse("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: zReadStateGrade.parse("none"),
712
- Viewed: zReadStateGrade.parse("viewed"),
713
- Reviewed: zReadStateGrade.parse("reviewed"),
714
- ReviewedInDetail: zReadStateGrade.parse("reviewed_in_detail"),
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: zRewriteMethod.parse("hash"),
722
- PatchID: zRewriteMethod.parse("patch_id"),
723
- AuthorIdentity: zRewriteMethod.parse("author_identity"),
724
- MessageEmbedded: zRewriteMethod.parse("message_embedded"),
725
- Temporal: zRewriteMethod.parse("temporal"),
726
- None: zRewriteMethod.parse("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: zRewriteResolution.parse("live"),
734
- Rewritten: zRewriteResolution.parse("rewritten"),
735
- Unresolved: zRewriteResolution.parse("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: zRole.parse("user"),
743
- Assistant: zRole.parse("assistant"),
744
- Tool: zRole.parse("tool"),
745
- System: zRole.parse("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: zScaleKind.parse("nominal"),
753
- Ordinal: zScaleKind.parse("ordinal"),
754
- Continuous: zScaleKind.parse("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: zSessionOrigin.parse("user"),
762
- Agent: zSessionOrigin.parse("agent"),
763
- Unknown: zSessionOrigin.parse("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: zSessionOutcome.parse("resolved"),
771
- Partial: zSessionOutcome.parse("partial"),
772
- Failed: zSessionOutcome.parse("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: zSourceFormat.parse("jsonl"),
780
- JSON: zSourceFormat.parse("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: zStopReason.parse("end_turn"),
788
- Cancelled: zStopReason.parse("cancelled"),
789
- MaxTokens: zStopReason.parse("max_tokens"),
790
- MaxTurnRequests: zStopReason.parse("max_turn_requests"),
791
- Refusal: zStopReason.parse("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: zTargetKind.parse("session"),
799
- Entry: zTargetKind.parse("entry"),
800
- Annotation: zTargetKind.parse("annotation"),
801
- Project: zTargetKind.parse("project"),
802
- FileVersion: zTargetKind.parse("file_version"),
803
- Association: zTargetKind.parse("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: zToolCallKind.parse("read"),
811
- Edit: zToolCallKind.parse("edit"),
812
- Delete: zToolCallKind.parse("delete"),
813
- Move: zToolCallKind.parse("move"),
814
- Search: zToolCallKind.parse("search"),
815
- Execute: zToolCallKind.parse("execute"),
816
- Think: zToolCallKind.parse("think"),
817
- Fetch: zToolCallKind.parse("fetch"),
818
- Other: zToolCallKind.parse("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: zTypeOrigin.parse("system"),
826
- User: zTypeOrigin.parse("user"),
827
- Group: zTypeOrigin.parse("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: zValueDomainKind.parse("enumerated"),
835
- Described: zValueDomainKind.parse("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: zTranscriptUpdateLicense.parse(""),
843
- CC0: zTranscriptUpdateLicense.parse("CC0-1.0"),
844
- CCBY: zTranscriptUpdateLicense.parse("CC-BY-4.0"),
845
- CCBYSA: zTranscriptUpdateLicense.parse("CC-BY-SA-4.0"),
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: zTranscriptUpdateVisibility.parse("private"),
853
- Public: zTranscriptUpdateVisibility.parse("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: zVillageAssignableCollectiveRole.parse("contributor"),
861
- Member: zVillageAssignableCollectiveRole.parse("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: zVillageContributionStatus.parse("approved"),
869
- Pending: zVillageContributionStatus.parse("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: zVillageCollectiveAcceptanceMode.parse("open"),
877
- VerifiedOnly: zVillageCollectiveAcceptanceMode.parse("verified_only"),
878
- Curated: zVillageCollectiveAcceptanceMode.parse("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: zVillageCollectiveDataAccess.parse("members_only"),
886
- Contributors: zVillageCollectiveDataAccess.parse("contributors"),
887
- Public: zVillageCollectiveDataAccess.parse("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: zVillageCollectiveRole.parse("owner"),
895
- Member: zVillageCollectiveRole.parse("member"),
896
- Contributor: zVillageCollectiveRole.parse("contributor"),
897
- Pending: zVillageCollectiveRole.parse("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: zVillageCollectiveViewerRole.parse(""),
905
- Owner: zVillageCollectiveViewerRole.parse("owner"),
906
- Member: zVillageCollectiveViewerRole.parse("member"),
907
- Contributor: zVillageCollectiveViewerRole.parse("contributor"),
908
- Pending: zVillageCollectiveViewerRole.parse("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: zVillageProjectNameSource.parse("override"),
916
- Consented: zVillageProjectNameSource.parse("consented"),
917
- Remote: zVillageProjectNameSource.parse("remote"),
918
- Path: zVillageProjectNameSource.parse("path"),
919
- Privacy: zVillageProjectNameSource.parse("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: zVillageReviewDecision.parse("approved"),
927
- Rejected: zVillageReviewDecision.parse("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: zVillageShareEventActor.parse(""),
935
- Owner: zVillageShareEventActor.parse("owner"),
936
- Collective: zVillageShareEventActor.parse("collective"),
937
- Moderator: zVillageShareEventActor.parse("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: zVillageShareStatus.parse("pending"),
945
- Approved: zVillageShareStatus.parse("approved"),
946
- Rejected: zVillageShareStatus.parse("rejected"),
947
- Retracted: zVillageShareStatus.parse("retracted"),
948
- Revoked: zVillageShareStatus.parse("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: zVillageTranscriptDeletionPolicy.parse("user_choice"),
956
- Mandatory: zVillageTranscriptDeletionPolicy.parse("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: zVillageTranscriptVisibility.parse("private"),
964
- Shared: zVillageTranscriptVisibility.parse("shared"),
965
- Public: zVillageTranscriptVisibility.parse("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: zVisibility.parse("private"),
973
- Group: zVisibility.parse("group"),
974
- Public: zVisibility.parse("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: zUsageScope.parse("assistant"),
982
- Tool: zUsageScope.parse("tool"),
983
- Summary: zUsageScope.parse("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: zUsageCompleteness.parse("complete"),
991
- Partial: zUsageCompleteness.parse("partial"),
992
- Unknown: zUsageCompleteness.parse("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: zNativeMetadataKind.parse("pi.custom.data"),
1000
- PiCustomMessageDetails: zNativeMetadataKind.parse("pi.custommessage.details"),
1001
- PiToolResultDetails: zNativeMetadataKind.parse("pi.toolresult.details"),
1002
- PiCompactionDetails: zNativeMetadataKind.parse("pi.compaction.details"),
1003
- PiBranchSummaryDetails: zNativeMetadataKind.parse("pi.branchsummary.details"),
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: zNativeMetadataSourceType.parse("pi.custom"),
1011
- PiCustomMessage: zNativeMetadataSourceType.parse("pi.custom_message"),
1012
- PiMessage: zNativeMetadataSourceType.parse("pi.message"),
1013
- PiCompaction: zNativeMetadataSourceType.parse("pi.compaction"),
1014
- PiBranchSummary: zNativeMetadataSourceType.parse("pi.branch_summary"),
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: zNativePiMessageRole.parse("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: zDigestItemKind.parse("session"),
1029
- Prompt: zDigestItemKind.parse("prompt"),
1030
- Skill: zDigestItemKind.parse("skill"),
1031
- Commit: zDigestItemKind.parse("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: zVillagePullRequestAttachmentState.parse("requested"),
1039
- Waiting: zVillagePullRequestAttachmentState.parse("waiting"),
1040
- Preview: zVillagePullRequestAttachmentState.parse("preview"),
1041
- Attached: zVillagePullRequestAttachmentState.parse("attached"),
1042
- Detached: zVillagePullRequestAttachmentState.parse("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: zVillagePromptsCheckMode.parse("informational"),
1050
- Required: zVillagePromptsCheckMode.parse("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: zVillagePublicOwnerKind.parse("profile"),
1058
- Anonymous: zVillagePublicOwnerKind.parse("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: zSessionRelationshipKind.parse("started_by"),
1066
- ContextFrom: zSessionRelationshipKind.parse("context_from"),
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: zRelationshipTargetState.parse("target_known"),
1074
- KnownRetained: zRelationshipTargetState.parse("target_known_retained"),
1075
- ExplicitNone: zRelationshipTargetState.parse("explicit_none"),
1076
- Unknown: zRelationshipTargetState.parse("unknown"),
1077
- ConflictingCurrentNativeEvidence: zRelationshipTargetState.parse("conflicting_current_native_evidence"),
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: zEvidenceKind.parse("native_typed"),
1085
- LifecycleTyped: zEvidenceKind.parse("lifecycle_typed"),
1086
- ExistingAdapter: zEvidenceKind.parse("existing_adapter"),
1087
- RetainedLastGood: zEvidenceKind.parse("retained_last_good"),
1088
- Unknown: zEvidenceKind.parse("unknown"),
1089
- Conflict: zEvidenceKind.parse("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: zSessionTeammateEvidence.parse("native_dynamic_workflow"),
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: zSessionPurpose.parse("interaction"),
1104
- DelegatedWork: zSessionPurpose.parse("delegated_work"),
1105
- HelperReview: zSessionPurpose.parse("helper_review"),
1106
- Unknown: zSessionPurpose.parse("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: zContentOrigin.parse("submitted_input"),
1114
- HarnessContext: zContentOrigin.parse("harness_context"),
1115
- AgentOutput: zContentOrigin.parse("agent_output"),
1116
- AgentCommunication: zContentOrigin.parse("agent_communication"),
1117
- ToolActivity: zContentOrigin.parse("tool_activity"),
1118
- SystemControl: zContentOrigin.parse("system_control"),
1119
- GeneratedSummary: zContentOrigin.parse("generated_summary"),
1120
- Unknown: zContentOrigin.parse("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: zActorOrigin.parse("operator"),
1128
- AgentDelegate: zActorOrigin.parse("agent_delegate"),
1129
- Harness: zActorOrigin.parse("harness"),
1130
- Unknown: zActorOrigin.parse("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: zDeliveryOrigin.parse("session_admission"),
1138
- GuardianReview: zDeliveryOrigin.parse("guardian_review"),
1139
- SubagentDelivery: zDeliveryOrigin.parse("subagent_delivery"),
1140
- InheritedContext: zDeliveryOrigin.parse("inherited_context"),
1141
- ToolDelivery: zDeliveryOrigin.parse("tool_delivery"),
1142
- SystemLifecycle: zDeliveryOrigin.parse("system_lifecycle"),
1143
- Unknown: zDeliveryOrigin.parse("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: zContentOwnership.parse("local"),
1151
- Inherited: zContentOwnership.parse("inherited"),
1152
- Uncertain: zContentOwnership.parse("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: zInputModality.parse("none"),
1160
- Text: zInputModality.parse("text"),
1161
- Media: zInputModality.parse("media"),
1162
- UserAction: zInputModality.parse("user_action"),
1163
- Mixed: zInputModality.parse("mixed"),
1164
- Unknown: zInputModality.parse("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: zPublicSourceAnchorKind.parse("general_source_session"),
1172
- Before: zPublicSourceAnchorKind.parse("before_redacted_entry"),
1173
- Through: zPublicSourceAnchorKind.parse("through_redacted_entry"),
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: zEarlierHistoryState.parse("uncertain_migrated"),
1181
- UncertainUnresolved: zEarlierHistoryState.parse("uncertain_unresolved"),
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: zRelationshipNavigationStatus.parse("resolved"),
1189
- GeneralLinkOnly: zRelationshipNavigationStatus.parse("general_link_only"),
1190
- KnownUnavailable: zRelationshipNavigationStatus.parse("known_unavailable"),
1191
- Inaccessible: zRelationshipNavigationStatus.parse("inaccessible"),
1192
- Unknown: zRelationshipNavigationStatus.parse("unknown"),
1193
- Conflicting: zRelationshipNavigationStatus.parse("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: zSessionListItemKind.parse("transcript"),
1201
- ContextContainer: zSessionListItemKind.parse("context_container"),
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: zSyncStatus.parse("new"),
1209
- Updated: zSyncStatus.parse("updated"),
1210
- Synced: zSyncStatus.parse("synced"),
1211
- Held: zSyncStatus.parse("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: zSyncHoldReason.parse("metrics_missing"),
1219
- MetadataMissing: zSyncHoldReason.parse("metadata_missing"),
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: zSyncPushSessionStatus.parse("new"),
1227
- Updated: zSyncPushSessionStatus.parse("updated"),
1228
- Skipped: zSyncPushSessionStatus.parse("skipped"),
1229
- Error: zSyncPushSessionStatus.parse("error"),
1230
- Held: zSyncPushSessionStatus.parse("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: zSyncPushStep.parse("content"),
1238
- AddCollective: zSyncPushStep.parse("add_collective"),
1239
- RemoveCollective: zSyncPushStep.parse("remove_collective"),
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: zSyncPushStepOutcome.parse("succeeded"),
1247
- PendingApproval: zSyncPushStepOutcome.parse("pending_approval"),
1248
- Skipped: zSyncPushStepOutcome.parse("skipped"),
1249
- Failed: zSyncPushStepOutcome.parse("failed"),
1250
- NotAttempted: zSyncPushStepOutcome.parse("not_attempted"),
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: zSyncLoginStatus.parse("pending"),
1258
- AlreadyAuthenticated: zSyncLoginStatus.parse("already_authenticated"),
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: zSyncLogoutStatus.parse("logged_out"),
1266
- AlreadyLoggedOut: zSyncLogoutStatus.parse("already_logged_out"),
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: zLocalPublicationState.parse("unpublished"),
1274
- Published: zLocalPublicationState.parse("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: zLocalCollectiveSuggestionReason.parse("linked_repository"),
1282
- LinkedGithubOrg: zLocalCollectiveSuggestionReason.parse("linked_github_org"),
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: zLocalSettingKind.parse("boolean"),
1290
- Integer: zLocalSettingKind.parse("integer"),
1291
- String: zLocalSettingKind.parse("string"),
1292
- StringList: zLocalSettingKind.parse("string_list"),
1293
- Choice: zLocalSettingKind.parse("choice"),
1294
- Structured: zLocalSettingKind.parse("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: zLocalKickstartScope.parse("full"),
1302
- Selection: zLocalKickstartScope.parse("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: zLocalKickstartStopKind.parse("connection"),
1310
- Config: zLocalKickstartStopKind.parse("config"),
1311
- Review: zLocalKickstartStopKind.parse("review"),
1312
- Ingest: zLocalKickstartStopKind.parse("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: zLocalKickstartFieldKind.parse("toggle"),
1320
- Choice: zLocalKickstartFieldKind.parse("choice"),
1321
- Action: zLocalKickstartFieldKind.parse("action"),
1322
- Tree: zLocalKickstartFieldKind.parse("tree"),
1323
- Notice: zLocalKickstartFieldKind.parse("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: zLocalKickstartLineKind.parse("text"),
1331
- Label: zLocalKickstartLineKind.parse("label"),
1332
- Before: zLocalKickstartLineKind.parse("before"),
1333
- After: zLocalKickstartLineKind.parse("after"),
1334
- Spacer: zLocalKickstartLineKind.parse("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: zLocalKickstartNodeKind.parse("project"),
1342
- Group: zLocalKickstartNodeKind.parse("group"),
1343
- Branch: zLocalKickstartNodeKind.parse("branch"),
1344
- Session: zLocalKickstartNodeKind.parse("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: zLocalKickstartNodeState.parse("none"),
1352
- Some: zLocalKickstartNodeState.parse("some"),
1353
- All: zLocalKickstartNodeState.parse("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: zLocalKickstartScanState.parse("idle"),
1361
- Running: zLocalKickstartScanState.parse("running"),
1362
- Done: zLocalKickstartScanState.parse("done"),
1363
- Error: zLocalKickstartScanState.parse("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: zLocalKickstartIngestState.parse("idle"),
1371
- Running: zLocalKickstartIngestState.parse("running"),
1372
- Busy: zLocalKickstartIngestState.parse("busy"),
1373
- Failed: zLocalKickstartIngestState.parse("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: zLocalKickstartResolution.parse("mine"),
1381
- Theirs: zLocalKickstartResolution.parse("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: zLocalKickstartNextStep.parse("config"),
1389
- WebStart: zLocalKickstartNextStep.parse("web-start"),
1390
- VillageLogin: zLocalKickstartNextStep.parse("village-login"),
1391
- VillagePush: zLocalKickstartNextStep.parse("village-push"),
1392
- AutoPublish: zLocalKickstartNextStep.parse("auto-publish-settings"),
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: zLocalKickstartDiffLineType.parse("add"),
1400
- Del: zLocalKickstartDiffLineType.parse("del"),
1401
- Ctx: zLocalKickstartDiffLineType.parse("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: zLocalKickstartEventKind.parse("session"),
1409
- Answers: zLocalKickstartEventKind.parse("answers"),
1410
- Conflicts: zLocalKickstartEventKind.parse("conflicts"),
1411
- Scan: zLocalKickstartEventKind.parse("scan"),
1412
- Ingest: zLocalKickstartEventKind.parse("ingest"),
1413
- Closed: zLocalKickstartEventKind.parse("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: zLocalKickstartCloseReason.parse("committed"),
1421
- Expired: zLocalKickstartCloseReason.parse("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: zLocalKickstartConnectAnswer.parse("accept"),
1429
- Skip: zLocalKickstartConnectAnswer.parse("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: zLocalKickstartErrorCode.parse("kickstart_body_missing"),
1437
- BodyInvalid: zLocalKickstartErrorCode.parse("kickstart_body_invalid"),
1438
- ScopeInvalid: zLocalKickstartErrorCode.parse("kickstart_scope_invalid"),
1439
- AnswersInvalid: zLocalKickstartErrorCode.parse("kickstart_answers_invalid"),
1440
- SessionCommitting: zLocalKickstartErrorCode.parse("kickstart_session_committing"),
1441
- RevisionAhead: zLocalKickstartErrorCode.parse("kickstart_revision_ahead"),
1442
- AnswerRefused: zLocalKickstartErrorCode.parse("kickstart_answer_refused"),
1443
- ScanNotDone: zLocalKickstartErrorCode.parse("kickstart_scan_not_done"),
1444
- FieldUnknown: zLocalKickstartErrorCode.parse("kickstart_field_unknown"),
1445
- FieldOutOfScope: zLocalKickstartErrorCode.parse("kickstart_field_out_of_scope"),
1446
- FieldHidden: zLocalKickstartErrorCode.parse("kickstart_field_hidden"),
1447
- TreeAnswerShape: zLocalKickstartErrorCode.parse("kickstart_tree_answer_shape"),
1448
- ConnectOutOfScope: zLocalKickstartErrorCode.parse("kickstart_connect_out_of_scope"),
1449
- ConnectNotConnected: zLocalKickstartErrorCode.parse("kickstart_connect_not_connected"),
1450
- ConnectUnknown: zLocalKickstartErrorCode.parse("kickstart_connect_unknown"),
1451
- CommitRefused: zLocalKickstartErrorCode.parse("kickstart_commit_refused"),
1452
- SessionNotFound: zLocalKickstartErrorCode.parse("kickstart_session_not_found"),
1453
- PreviewRowNotFound: zLocalKickstartErrorCode.parse("kickstart_preview_row_not_found"),
1454
- Failed: zLocalKickstartErrorCode.parse("kickstart_failed"),
1455
- StatusUnreadable: zLocalKickstartErrorCode.parse("kickstart_status_unreadable"),
1456
- ConfigUnreadable: zLocalKickstartErrorCode.parse("kickstart_config_unreadable"),
1457
- ConfigUnwritable: zLocalKickstartErrorCode.parse("kickstart_config_unwritable"),
1458
- SessionUnbuildable: zLocalKickstartErrorCode.parse("kickstart_session_unbuildable"),
1459
- AnswerUnencodable: zLocalKickstartErrorCode.parse("kickstart_answer_unencodable"),
1460
- PreviewUnreadable: zLocalKickstartErrorCode.parse("kickstart_preview_unreadable"),
1461
- ContractBreach: zLocalKickstartErrorCode.parse("publishing_contract_breach"),
1462
- Unavailable: zLocalKickstartErrorCode.parse("kickstart_unavailable"),
1463
- ConfigBusy: zLocalKickstartErrorCode.parse("kickstart_config_busy"),
1464
- ConfigChanging: zLocalKickstartErrorCode.parse("kickstart_config_changing"),
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: zAutoPublishEvent.parse("pre-push"),
1472
- PostCommit: zAutoPublishEvent.parse("post-commit"),
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: zAutoPublishHookStatus.parse("absent"),
1480
- Installed: zAutoPublishHookStatus.parse("installed"),
1481
- Blocked: zAutoPublishHookStatus.parse("blocked"),
1482
- Failed: zAutoPublishHookStatus.parse("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: zAutoPublishRuleKind.parse("folder"),
1490
- Remote: zAutoPublishRuleKind.parse("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: zThinkingLevel.parse("off"),
1498
- Minimal: zThinkingLevel.parse("minimal"),
1499
- Low: zThinkingLevel.parse("low"),
1500
- Medium: zThinkingLevel.parse("medium"),
1501
- High: zThinkingLevel.parse("high"),
1502
- XHigh: zThinkingLevel.parse("xhigh"),
1503
- Max: zThinkingLevel.parse("max"),
1504
- Ultra: zThinkingLevel.parse("ultra"),
1505
- Ultracode: zThinkingLevel.parse("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: zScryVerdict.parse("checked"),
1513
- Unchecked: zScryVerdict.parse("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) {