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