@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.
- package/README.md +8 -0
- package/dist/fixtures/session-graph.d.ts +8 -0
- package/dist/index.d.ts +32 -0
- package/dist/index.js +212 -3
- package/dist/internal/generated/contract/zod.gen.d.ts +5446 -4807
- package/dist/internal/generated/contract/zod.gen.js +778 -556
- package/dist/internal/generated/enums.gen.d.ts +740 -800
- package/dist/internal/generated/enums.gen.js +615 -529
- package/dist/internal/generated/public-contract.gen.d.ts +2 -2
- package/dist/internal/generated/public-contract.gen.js +1 -1
- package/dist/internal/generated/routes.gen.d.ts +9 -1
- package/dist/internal/generated/routes.gen.js +10 -0
- package/dist/internal/generated/session-graph-fixtures.gen.d.ts +8 -0
- package/dist/internal/generated/session-graph-fixtures.gen.js +10 -0
- package/dist/internal/generated/versions.gen.d.ts +4 -2
- package/dist/internal/generated/versions.gen.js +4 -2
- package/dist/internal/generated/village-api.d.ts +590 -9
- package/dist/transcript-directory-positions.d.ts +3 -0
- package/dist/transcript-directory-positions.js +89 -0
- package/dist/transcript-served-turn.d.ts +17 -0
- package/dist/transcript-served-turn.js +11 -0
- package/package.json +1 -1
|
@@ -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:
|
|
132
|
-
Contribution:
|
|
133
|
-
Organization:
|
|
134
|
-
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:
|
|
142
|
-
Unavailable:
|
|
143
|
-
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:
|
|
151
|
-
Share:
|
|
152
|
-
Fetch:
|
|
153
|
-
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:
|
|
161
|
-
Remote:
|
|
162
|
-
Contract:
|
|
163
|
-
Deadline:
|
|
164
|
-
Persistence:
|
|
165
|
-
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:
|
|
173
|
-
Receipts:
|
|
174
|
-
OperationDiagnostics:
|
|
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:
|
|
182
|
-
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:
|
|
190
|
-
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:
|
|
198
|
-
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:
|
|
206
|
-
Stale:
|
|
207
|
-
Unknown:
|
|
208
|
-
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:
|
|
216
|
-
History:
|
|
217
|
-
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:
|
|
225
|
-
Failed:
|
|
226
|
-
Cancelled:
|
|
227
|
-
Superseded:
|
|
228
|
-
NotRequested:
|
|
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:
|
|
236
|
-
Unchanged:
|
|
237
|
-
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:
|
|
245
|
-
Partial:
|
|
246
|
-
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:
|
|
254
|
-
ContributionDiscovery:
|
|
255
|
-
Organization:
|
|
256
|
-
Explicit:
|
|
257
|
-
Submissions:
|
|
258
|
-
Attempts:
|
|
259
|
-
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:
|
|
267
|
-
NotDisclosed:
|
|
268
|
-
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:
|
|
276
|
-
NotPublished:
|
|
277
|
-
Published:
|
|
278
|
-
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:
|
|
286
|
-
P50:
|
|
287
|
-
P100:
|
|
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:
|
|
295
|
-
Replace:
|
|
296
|
-
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:
|
|
304
|
-
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:
|
|
312
|
-
Session:
|
|
313
|
-
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:
|
|
321
|
-
Integer:
|
|
322
|
-
Real:
|
|
323
|
-
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:
|
|
331
|
-
Updated:
|
|
332
|
-
Skipped:
|
|
333
|
-
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:
|
|
341
|
-
Active:
|
|
342
|
-
Deprecated:
|
|
343
|
-
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:
|
|
351
|
-
Agent:
|
|
352
|
-
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:
|
|
360
|
-
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:
|
|
368
|
-
TouchedFile:
|
|
369
|
-
BranchMembership:
|
|
370
|
-
TimeWindow:
|
|
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:
|
|
378
|
-
Compact:
|
|
379
|
-
Clear:
|
|
380
|
-
New:
|
|
381
|
-
Model:
|
|
382
|
-
Usage:
|
|
383
|
-
Cost:
|
|
384
|
-
Context:
|
|
385
|
-
Plugin:
|
|
386
|
-
Permissions:
|
|
387
|
-
Login:
|
|
388
|
-
Resume:
|
|
389
|
-
Plan:
|
|
390
|
-
Fast:
|
|
391
|
-
Voice:
|
|
392
|
-
Todos:
|
|
393
|
-
ReloadPlugins:
|
|
394
|
-
Sandbox:
|
|
395
|
-
Config:
|
|
396
|
-
Statusline:
|
|
397
|
-
Upgrade:
|
|
398
|
-
ExtraUsage:
|
|
399
|
-
RateLimitOptions:
|
|
400
|
-
PrivacySettings:
|
|
401
|
-
Help:
|
|
402
|
-
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:
|
|
410
|
-
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:
|
|
418
|
-
Sessions:
|
|
419
|
-
SessionDetail:
|
|
420
|
-
Trends:
|
|
421
|
-
Quality:
|
|
422
|
-
Annotations:
|
|
423
|
-
ProjectFamiliarity:
|
|
424
|
-
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:
|
|
432
|
-
Medium:
|
|
433
|
-
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:
|
|
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:
|
|
448
|
-
Fading:
|
|
449
|
-
Stale:
|
|
450
|
-
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:
|
|
458
|
-
Add:
|
|
459
|
-
Delete:
|
|
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:
|
|
467
|
-
WrongWay:
|
|
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:
|
|
475
|
-
ToolUse:
|
|
476
|
-
ToolResult:
|
|
477
|
-
Thinking:
|
|
478
|
-
System:
|
|
479
|
-
Error:
|
|
480
|
-
Result:
|
|
481
|
-
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:
|
|
489
|
-
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:
|
|
497
|
-
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:
|
|
505
|
-
Unsupported:
|
|
506
|
-
Missing:
|
|
507
|
-
NotPublished:
|
|
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:
|
|
515
|
-
Added:
|
|
516
|
-
Deleted:
|
|
517
|
-
Renamed:
|
|
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:
|
|
525
|
-
GeminiCLI:
|
|
526
|
-
Codex:
|
|
527
|
-
OpenCode:
|
|
528
|
-
Cursor:
|
|
529
|
-
Antigravity:
|
|
530
|
-
Strike:
|
|
531
|
-
Pi:
|
|
532
|
-
GrokBuild:
|
|
533
|
-
DevinDesktop:
|
|
534
|
-
Cline:
|
|
535
|
-
Kiro:
|
|
536
|
-
KiroCLI:
|
|
537
|
-
KiroCrew:
|
|
538
|
-
AntigravityCLI:
|
|
539
|
-
AntigravityIDE:
|
|
610
|
+
ClaudeCode: "claude-code",
|
|
611
|
+
GeminiCLI: "gemini-cli",
|
|
612
|
+
Codex: "codex",
|
|
613
|
+
OpenCode: "opencode",
|
|
614
|
+
Cursor: "cursor",
|
|
615
|
+
Antigravity: "antigravity",
|
|
616
|
+
Strike: "strike",
|
|
617
|
+
Pi: "pi",
|
|
618
|
+
GrokBuild: "grok-build",
|
|
619
|
+
DevinDesktop: "devin-desktop",
|
|
620
|
+
Cline: "cline",
|
|
621
|
+
Kiro: "kiro",
|
|
622
|
+
KiroCLI: "kiro-cli",
|
|
623
|
+
KiroCrew: "kiro-crew",
|
|
624
|
+
AntigravityCLI: "antigravity-cli",
|
|
625
|
+
AntigravityIDE: "antigravity-ide",
|
|
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:
|
|
553
|
-
Friction:
|
|
554
|
-
Unusual:
|
|
555
|
-
RetryLoop:
|
|
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:
|
|
563
|
-
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:
|
|
571
|
-
Read:
|
|
572
|
-
Discussed:
|
|
573
|
-
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:
|
|
581
|
-
CCBY:
|
|
582
|
-
CCBYSA:
|
|
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:
|
|
590
|
-
Package:
|
|
591
|
-
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:
|
|
599
|
-
Unsubscribe:
|
|
600
|
-
Dashboard:
|
|
601
|
-
Sessions:
|
|
602
|
-
SessionDetail:
|
|
603
|
-
Trends:
|
|
604
|
-
Quality:
|
|
605
|
-
Annotations:
|
|
606
|
-
ProjectFamiliarity:
|
|
607
|
-
Connected:
|
|
608
|
-
Error:
|
|
609
|
-
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:
|
|
617
|
-
Partial:
|
|
618
|
-
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:
|
|
626
|
-
Viewed:
|
|
627
|
-
Reviewed:
|
|
628
|
-
ReviewedInDetail:
|
|
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:
|
|
636
|
-
PatchID:
|
|
637
|
-
AuthorIdentity:
|
|
638
|
-
MessageEmbedded:
|
|
639
|
-
Temporal:
|
|
640
|
-
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:
|
|
648
|
-
Rewritten:
|
|
649
|
-
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:
|
|
657
|
-
Assistant:
|
|
658
|
-
Tool:
|
|
659
|
-
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:
|
|
667
|
-
Ordinal:
|
|
668
|
-
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:
|
|
676
|
-
Agent:
|
|
677
|
-
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:
|
|
685
|
-
Partial:
|
|
686
|
-
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:
|
|
694
|
-
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:
|
|
702
|
-
Cancelled:
|
|
703
|
-
MaxTokens:
|
|
704
|
-
MaxTurnRequests:
|
|
705
|
-
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:
|
|
713
|
-
Entry:
|
|
714
|
-
Annotation:
|
|
715
|
-
Project:
|
|
716
|
-
FileVersion:
|
|
717
|
-
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:
|
|
725
|
-
Edit:
|
|
726
|
-
Delete:
|
|
727
|
-
Move:
|
|
728
|
-
Search:
|
|
729
|
-
Execute:
|
|
730
|
-
Think:
|
|
731
|
-
Fetch:
|
|
732
|
-
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:
|
|
740
|
-
User:
|
|
741
|
-
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:
|
|
749
|
-
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:
|
|
757
|
-
CC0:
|
|
758
|
-
CCBY:
|
|
759
|
-
CCBYSA:
|
|
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:
|
|
767
|
-
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:
|
|
775
|
-
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:
|
|
783
|
-
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:
|
|
791
|
-
VerifiedOnly:
|
|
792
|
-
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:
|
|
800
|
-
Contributors:
|
|
801
|
-
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:
|
|
809
|
-
Member:
|
|
810
|
-
Contributor:
|
|
811
|
-
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:
|
|
819
|
-
Owner:
|
|
820
|
-
Member:
|
|
821
|
-
Contributor:
|
|
822
|
-
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:
|
|
830
|
-
Consented:
|
|
831
|
-
Remote:
|
|
832
|
-
Path:
|
|
833
|
-
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:
|
|
841
|
-
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:
|
|
849
|
-
Owner:
|
|
850
|
-
Collective:
|
|
851
|
-
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:
|
|
859
|
-
Approved:
|
|
860
|
-
Rejected:
|
|
861
|
-
Retracted:
|
|
862
|
-
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:
|
|
870
|
-
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:
|
|
878
|
-
Shared:
|
|
879
|
-
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:
|
|
887
|
-
Group:
|
|
888
|
-
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:
|
|
896
|
-
Tool:
|
|
897
|
-
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:
|
|
905
|
-
Partial:
|
|
906
|
-
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:
|
|
914
|
-
PiCustomMessageDetails:
|
|
915
|
-
PiToolResultDetails:
|
|
916
|
-
PiCompactionDetails:
|
|
917
|
-
PiBranchSummaryDetails:
|
|
999
|
+
PiCustomData: "pi.custom.data",
|
|
1000
|
+
PiCustomMessageDetails: "pi.custommessage.details",
|
|
1001
|
+
PiToolResultDetails: "pi.toolresult.details",
|
|
1002
|
+
PiCompactionDetails: "pi.compaction.details",
|
|
1003
|
+
PiBranchSummaryDetails: "pi.branchsummary.details",
|
|
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:
|
|
925
|
-
PiCustomMessage:
|
|
926
|
-
PiMessage:
|
|
927
|
-
PiCompaction:
|
|
928
|
-
PiBranchSummary:
|
|
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:
|
|
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:
|
|
943
|
-
Prompt:
|
|
944
|
-
Skill:
|
|
945
|
-
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:
|
|
953
|
-
Waiting:
|
|
954
|
-
Preview:
|
|
955
|
-
Attached:
|
|
956
|
-
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:
|
|
964
|
-
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:
|
|
972
|
-
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:
|
|
980
|
-
ContextFrom:
|
|
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:
|
|
988
|
-
KnownRetained:
|
|
989
|
-
ExplicitNone:
|
|
990
|
-
Unknown:
|
|
991
|
-
ConflictingCurrentNativeEvidence:
|
|
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:
|
|
999
|
-
LifecycleTyped:
|
|
1000
|
-
ExistingAdapter:
|
|
1001
|
-
RetainedLastGood:
|
|
1002
|
-
Unknown:
|
|
1003
|
-
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:
|
|
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:
|
|
1018
|
-
DelegatedWork:
|
|
1019
|
-
HelperReview:
|
|
1020
|
-
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:
|
|
1028
|
-
HarnessContext:
|
|
1029
|
-
AgentOutput:
|
|
1030
|
-
AgentCommunication:
|
|
1031
|
-
ToolActivity:
|
|
1032
|
-
SystemControl:
|
|
1033
|
-
GeneratedSummary:
|
|
1034
|
-
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:
|
|
1042
|
-
AgentDelegate:
|
|
1043
|
-
Harness:
|
|
1044
|
-
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:
|
|
1052
|
-
GuardianReview:
|
|
1053
|
-
SubagentDelivery:
|
|
1054
|
-
InheritedContext:
|
|
1055
|
-
ToolDelivery:
|
|
1056
|
-
SystemLifecycle:
|
|
1057
|
-
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:
|
|
1065
|
-
Inherited:
|
|
1066
|
-
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:
|
|
1074
|
-
Text:
|
|
1075
|
-
Media:
|
|
1076
|
-
UserAction:
|
|
1077
|
-
Mixed:
|
|
1078
|
-
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:
|
|
1086
|
-
Before:
|
|
1087
|
-
Through:
|
|
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:
|
|
1095
|
-
UncertainUnresolved:
|
|
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:
|
|
1103
|
-
GeneralLinkOnly:
|
|
1104
|
-
KnownUnavailable:
|
|
1105
|
-
Inaccessible:
|
|
1106
|
-
Unknown:
|
|
1107
|
-
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:
|
|
1115
|
-
ContextContainer:
|
|
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:
|
|
1123
|
-
Updated:
|
|
1124
|
-
Synced:
|
|
1125
|
-
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:
|
|
1133
|
-
MetadataMissing:
|
|
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:
|
|
1141
|
-
Updated:
|
|
1142
|
-
Skipped:
|
|
1143
|
-
Error:
|
|
1144
|
-
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:
|
|
1152
|
-
AddCollective:
|
|
1153
|
-
RemoveCollective:
|
|
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:
|
|
1161
|
-
PendingApproval:
|
|
1162
|
-
Skipped:
|
|
1163
|
-
Failed:
|
|
1164
|
-
NotAttempted:
|
|
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:
|
|
1172
|
-
AlreadyAuthenticated:
|
|
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:
|
|
1180
|
-
AlreadyLoggedOut:
|
|
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:
|
|
1188
|
-
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:
|
|
1196
|
-
LinkedGithubOrg:
|
|
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:
|
|
1204
|
-
Integer:
|
|
1205
|
-
String:
|
|
1206
|
-
StringList:
|
|
1207
|
-
Choice:
|
|
1208
|
-
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:
|
|
1216
|
-
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:
|
|
1224
|
-
Config:
|
|
1225
|
-
Review:
|
|
1226
|
-
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:
|
|
1234
|
-
Choice:
|
|
1235
|
-
Action:
|
|
1236
|
-
Tree:
|
|
1237
|
-
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:
|
|
1245
|
-
Label:
|
|
1246
|
-
Before:
|
|
1247
|
-
After:
|
|
1248
|
-
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:
|
|
1256
|
-
Group:
|
|
1257
|
-
Branch:
|
|
1258
|
-
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:
|
|
1266
|
-
Some:
|
|
1267
|
-
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:
|
|
1275
|
-
Running:
|
|
1276
|
-
Done:
|
|
1277
|
-
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:
|
|
1285
|
-
Running:
|
|
1286
|
-
Busy:
|
|
1287
|
-
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:
|
|
1295
|
-
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:
|
|
1303
|
-
WebStart:
|
|
1304
|
-
VillageLogin:
|
|
1305
|
-
VillagePush:
|
|
1306
|
-
AutoPublish:
|
|
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:
|
|
1314
|
-
Del:
|
|
1315
|
-
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:
|
|
1323
|
-
Answers:
|
|
1324
|
-
Conflicts:
|
|
1325
|
-
Scan:
|
|
1326
|
-
Ingest:
|
|
1327
|
-
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:
|
|
1335
|
-
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:
|
|
1343
|
-
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:
|
|
1351
|
-
BodyInvalid:
|
|
1352
|
-
ScopeInvalid:
|
|
1353
|
-
AnswersInvalid:
|
|
1354
|
-
SessionCommitting:
|
|
1355
|
-
RevisionAhead:
|
|
1356
|
-
AnswerRefused:
|
|
1357
|
-
ScanNotDone:
|
|
1358
|
-
FieldUnknown:
|
|
1359
|
-
FieldOutOfScope:
|
|
1360
|
-
FieldHidden:
|
|
1361
|
-
TreeAnswerShape:
|
|
1362
|
-
ConnectOutOfScope:
|
|
1363
|
-
ConnectNotConnected:
|
|
1364
|
-
ConnectUnknown:
|
|
1365
|
-
CommitRefused:
|
|
1366
|
-
SessionNotFound:
|
|
1367
|
-
PreviewRowNotFound:
|
|
1368
|
-
Failed:
|
|
1369
|
-
StatusUnreadable:
|
|
1370
|
-
ConfigUnreadable:
|
|
1371
|
-
ConfigUnwritable:
|
|
1372
|
-
SessionUnbuildable:
|
|
1373
|
-
AnswerUnencodable:
|
|
1374
|
-
PreviewUnreadable:
|
|
1375
|
-
ContractBreach:
|
|
1376
|
-
Unavailable:
|
|
1377
|
-
ConfigBusy:
|
|
1378
|
-
ConfigChanging:
|
|
1436
|
+
BodyMissing: "kickstart_body_missing",
|
|
1437
|
+
BodyInvalid: "kickstart_body_invalid",
|
|
1438
|
+
ScopeInvalid: "kickstart_scope_invalid",
|
|
1439
|
+
AnswersInvalid: "kickstart_answers_invalid",
|
|
1440
|
+
SessionCommitting: "kickstart_session_committing",
|
|
1441
|
+
RevisionAhead: "kickstart_revision_ahead",
|
|
1442
|
+
AnswerRefused: "kickstart_answer_refused",
|
|
1443
|
+
ScanNotDone: "kickstart_scan_not_done",
|
|
1444
|
+
FieldUnknown: "kickstart_field_unknown",
|
|
1445
|
+
FieldOutOfScope: "kickstart_field_out_of_scope",
|
|
1446
|
+
FieldHidden: "kickstart_field_hidden",
|
|
1447
|
+
TreeAnswerShape: "kickstart_tree_answer_shape",
|
|
1448
|
+
ConnectOutOfScope: "kickstart_connect_out_of_scope",
|
|
1449
|
+
ConnectNotConnected: "kickstart_connect_not_connected",
|
|
1450
|
+
ConnectUnknown: "kickstart_connect_unknown",
|
|
1451
|
+
CommitRefused: "kickstart_commit_refused",
|
|
1452
|
+
SessionNotFound: "kickstart_session_not_found",
|
|
1453
|
+
PreviewRowNotFound: "kickstart_preview_row_not_found",
|
|
1454
|
+
Failed: "kickstart_failed",
|
|
1455
|
+
StatusUnreadable: "kickstart_status_unreadable",
|
|
1456
|
+
ConfigUnreadable: "kickstart_config_unreadable",
|
|
1457
|
+
ConfigUnwritable: "kickstart_config_unwritable",
|
|
1458
|
+
SessionUnbuildable: "kickstart_session_unbuildable",
|
|
1459
|
+
AnswerUnencodable: "kickstart_answer_unencodable",
|
|
1460
|
+
PreviewUnreadable: "kickstart_preview_unreadable",
|
|
1461
|
+
ContractBreach: "publishing_contract_breach",
|
|
1462
|
+
Unavailable: "kickstart_unavailable",
|
|
1463
|
+
ConfigBusy: "kickstart_config_busy",
|
|
1464
|
+
ConfigChanging: "kickstart_config_changing",
|
|
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:
|
|
1386
|
-
PostCommit:
|
|
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:
|
|
1394
|
-
Installed:
|
|
1395
|
-
Blocked:
|
|
1396
|
-
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:
|
|
1404
|
-
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:
|
|
1412
|
-
Minimal:
|
|
1413
|
-
Low:
|
|
1414
|
-
Medium:
|
|
1415
|
-
High:
|
|
1416
|
-
XHigh:
|
|
1417
|
-
Max:
|
|
1418
|
-
Ultra:
|
|
1419
|
-
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:
|
|
1427
|
-
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) {
|