@mossbear/protocol 0.1.0-alpha.104 → 0.1.0-alpha.106
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/dist/artifact.test.js +13 -0
- package/dist/artifact.test.js.map +1 -1
- package/dist/schemas.d.ts +605 -0
- package/dist/schemas.d.ts.map +1 -1
- package/dist/schemas.js +75 -0
- package/dist/schemas.js.map +1 -1
- package/dist/types.d.ts +3 -1
- package/dist/types.d.ts.map +1 -1
- package/dist/types.js.map +1 -1
- package/package.json +1 -1
package/dist/schemas.d.ts
CHANGED
|
@@ -1173,6 +1173,16 @@ export declare const CommentFindingSchema: v.ObjectSchema<{
|
|
|
1173
1173
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1174
1174
|
}, undefined>;
|
|
1175
1175
|
export type CommentFinding = v.InferOutput<typeof CommentFindingSchema>;
|
|
1176
|
+
/** Whether an open Mossbear finding is the agent's to act on (`ArtifactComment.findingState`). */
|
|
1177
|
+
export declare const CommentFindingStateSchema: v.PicklistSchema<["ready", "waiting"], undefined>;
|
|
1178
|
+
export type CommentFindingState = v.InferOutput<typeof CommentFindingStateSchema>;
|
|
1179
|
+
/** Where a commented artifact is published from (`ArtifactComment.publishedFrom`). */
|
|
1180
|
+
export declare const CommentPublishedFromSchema: v.ObjectSchema<{
|
|
1181
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1182
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
1183
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1184
|
+
}, undefined>;
|
|
1185
|
+
export type CommentPublishedFrom = v.InferOutput<typeof CommentPublishedFromSchema>;
|
|
1176
1186
|
/**
|
|
1177
1187
|
* One comment a **person** left about a context item, riding the item it is about.
|
|
1178
1188
|
*
|
|
@@ -1223,6 +1233,30 @@ export declare const ArtifactCommentSchema: v.ObjectSchema<{
|
|
|
1223
1233
|
* strips this field never receives a draft it would print as a request.
|
|
1224
1234
|
*/
|
|
1225
1235
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1236
|
+
/**
|
|
1237
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
1238
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
1239
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
1240
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
1241
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
1242
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
1243
|
+
* which already says open or resolved.
|
|
1244
|
+
*/
|
|
1245
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
1246
|
+
/**
|
|
1247
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
1248
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
1249
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
1250
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
1251
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
1252
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
1253
|
+
* Mossbear-owned.
|
|
1254
|
+
*/
|
|
1255
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
1256
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1257
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
1258
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1259
|
+
}, undefined>, undefined>;
|
|
1226
1260
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
1227
1261
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1228
1262
|
/**
|
|
@@ -1329,6 +1363,30 @@ export declare const ContextItemCommentSchema: v.ObjectSchema<{
|
|
|
1329
1363
|
* strips this field never receives a draft it would print as a request.
|
|
1330
1364
|
*/
|
|
1331
1365
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1366
|
+
/**
|
|
1367
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
1368
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
1369
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
1370
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
1371
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
1372
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
1373
|
+
* which already says open or resolved.
|
|
1374
|
+
*/
|
|
1375
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
1376
|
+
/**
|
|
1377
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
1378
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
1379
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
1380
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
1381
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
1382
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
1383
|
+
* Mossbear-owned.
|
|
1384
|
+
*/
|
|
1385
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
1386
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1387
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
1388
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1389
|
+
}, undefined>, undefined>;
|
|
1332
1390
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
1333
1391
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1334
1392
|
/**
|
|
@@ -1598,6 +1656,30 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1598
1656
|
* strips this field never receives a draft it would print as a request.
|
|
1599
1657
|
*/
|
|
1600
1658
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1659
|
+
/**
|
|
1660
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
1661
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
1662
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
1663
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
1664
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
1665
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
1666
|
+
* which already says open or resolved.
|
|
1667
|
+
*/
|
|
1668
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
1669
|
+
/**
|
|
1670
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
1671
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
1672
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
1673
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
1674
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
1675
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
1676
|
+
* Mossbear-owned.
|
|
1677
|
+
*/
|
|
1678
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
1679
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1680
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
1681
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1682
|
+
}, undefined>, undefined>;
|
|
1601
1683
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
1602
1684
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1603
1685
|
/**
|
|
@@ -1683,6 +1765,12 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1683
1765
|
prediction: string | null;
|
|
1684
1766
|
} | undefined;
|
|
1685
1767
|
approved?: boolean | undefined;
|
|
1768
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
1769
|
+
publishedFrom?: {
|
|
1770
|
+
projectId: string;
|
|
1771
|
+
branch: string | null;
|
|
1772
|
+
thisRepo?: boolean | undefined;
|
|
1773
|
+
} | undefined;
|
|
1686
1774
|
authorName: string | null;
|
|
1687
1775
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
1688
1776
|
createdAt: string;
|
|
@@ -1828,6 +1916,12 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1828
1916
|
prediction: string | null;
|
|
1829
1917
|
} | undefined;
|
|
1830
1918
|
approved?: boolean | undefined;
|
|
1919
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
1920
|
+
publishedFrom?: {
|
|
1921
|
+
projectId: string;
|
|
1922
|
+
branch: string | null;
|
|
1923
|
+
thisRepo?: boolean | undefined;
|
|
1924
|
+
} | undefined;
|
|
1831
1925
|
authorName: string | null;
|
|
1832
1926
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
1833
1927
|
createdAt: string;
|
|
@@ -1897,6 +1991,12 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1897
1991
|
prediction: string | null;
|
|
1898
1992
|
} | undefined;
|
|
1899
1993
|
approved?: boolean | undefined;
|
|
1994
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
1995
|
+
publishedFrom?: {
|
|
1996
|
+
projectId: string;
|
|
1997
|
+
branch: string | null;
|
|
1998
|
+
thisRepo?: boolean | undefined;
|
|
1999
|
+
} | undefined;
|
|
1900
2000
|
authorName: string | null;
|
|
1901
2001
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
1902
2002
|
createdAt: string;
|
|
@@ -2068,6 +2168,30 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2068
2168
|
* strips this field never receives a draft it would print as a request.
|
|
2069
2169
|
*/
|
|
2070
2170
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2171
|
+
/**
|
|
2172
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
2173
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
2174
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
2175
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
2176
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
2177
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
2178
|
+
* which already says open or resolved.
|
|
2179
|
+
*/
|
|
2180
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
2181
|
+
/**
|
|
2182
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
2183
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
2184
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
2185
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
2186
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
2187
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
2188
|
+
* Mossbear-owned.
|
|
2189
|
+
*/
|
|
2190
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
2191
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2192
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
2193
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2194
|
+
}, undefined>, undefined>;
|
|
2071
2195
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
2072
2196
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
2073
2197
|
/**
|
|
@@ -2153,6 +2277,12 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2153
2277
|
prediction: string | null;
|
|
2154
2278
|
} | undefined;
|
|
2155
2279
|
approved?: boolean | undefined;
|
|
2280
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
2281
|
+
publishedFrom?: {
|
|
2282
|
+
projectId: string;
|
|
2283
|
+
branch: string | null;
|
|
2284
|
+
thisRepo?: boolean | undefined;
|
|
2285
|
+
} | undefined;
|
|
2156
2286
|
authorName: string | null;
|
|
2157
2287
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
2158
2288
|
createdAt: string;
|
|
@@ -2298,6 +2428,12 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2298
2428
|
prediction: string | null;
|
|
2299
2429
|
} | undefined;
|
|
2300
2430
|
approved?: boolean | undefined;
|
|
2431
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
2432
|
+
publishedFrom?: {
|
|
2433
|
+
projectId: string;
|
|
2434
|
+
branch: string | null;
|
|
2435
|
+
thisRepo?: boolean | undefined;
|
|
2436
|
+
} | undefined;
|
|
2301
2437
|
authorName: string | null;
|
|
2302
2438
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
2303
2439
|
createdAt: string;
|
|
@@ -2367,6 +2503,12 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2367
2503
|
prediction: string | null;
|
|
2368
2504
|
} | undefined;
|
|
2369
2505
|
approved?: boolean | undefined;
|
|
2506
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
2507
|
+
publishedFrom?: {
|
|
2508
|
+
projectId: string;
|
|
2509
|
+
branch: string | null;
|
|
2510
|
+
thisRepo?: boolean | undefined;
|
|
2511
|
+
} | undefined;
|
|
2370
2512
|
authorName: string | null;
|
|
2371
2513
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
2372
2514
|
createdAt: string;
|
|
@@ -2556,6 +2698,30 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2556
2698
|
* strips this field never receives a draft it would print as a request.
|
|
2557
2699
|
*/
|
|
2558
2700
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2701
|
+
/**
|
|
2702
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
2703
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
2704
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
2705
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
2706
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
2707
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
2708
|
+
* which already says open or resolved.
|
|
2709
|
+
*/
|
|
2710
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
2711
|
+
/**
|
|
2712
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
2713
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
2714
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
2715
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
2716
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
2717
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
2718
|
+
* Mossbear-owned.
|
|
2719
|
+
*/
|
|
2720
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
2721
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2722
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
2723
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2724
|
+
}, undefined>, undefined>;
|
|
2559
2725
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
2560
2726
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
2561
2727
|
/**
|
|
@@ -2641,6 +2807,12 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2641
2807
|
prediction: string | null;
|
|
2642
2808
|
} | undefined;
|
|
2643
2809
|
approved?: boolean | undefined;
|
|
2810
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
2811
|
+
publishedFrom?: {
|
|
2812
|
+
projectId: string;
|
|
2813
|
+
branch: string | null;
|
|
2814
|
+
thisRepo?: boolean | undefined;
|
|
2815
|
+
} | undefined;
|
|
2644
2816
|
authorName: string | null;
|
|
2645
2817
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
2646
2818
|
createdAt: string;
|
|
@@ -2786,6 +2958,12 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2786
2958
|
prediction: string | null;
|
|
2787
2959
|
} | undefined;
|
|
2788
2960
|
approved?: boolean | undefined;
|
|
2961
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
2962
|
+
publishedFrom?: {
|
|
2963
|
+
projectId: string;
|
|
2964
|
+
branch: string | null;
|
|
2965
|
+
thisRepo?: boolean | undefined;
|
|
2966
|
+
} | undefined;
|
|
2789
2967
|
authorName: string | null;
|
|
2790
2968
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
2791
2969
|
createdAt: string;
|
|
@@ -2855,6 +3033,12 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2855
3033
|
prediction: string | null;
|
|
2856
3034
|
} | undefined;
|
|
2857
3035
|
approved?: boolean | undefined;
|
|
3036
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
3037
|
+
publishedFrom?: {
|
|
3038
|
+
projectId: string;
|
|
3039
|
+
branch: string | null;
|
|
3040
|
+
thisRepo?: boolean | undefined;
|
|
3041
|
+
} | undefined;
|
|
2858
3042
|
authorName: string | null;
|
|
2859
3043
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
2860
3044
|
createdAt: string;
|
|
@@ -3150,6 +3334,30 @@ export declare const ItemCommentWithSubjectSchema: v.ObjectSchema<{
|
|
|
3150
3334
|
* strips this field never receives a draft it would print as a request.
|
|
3151
3335
|
*/
|
|
3152
3336
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
3337
|
+
/**
|
|
3338
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
3339
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
3340
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
3341
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
3342
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
3343
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
3344
|
+
* which already says open or resolved.
|
|
3345
|
+
*/
|
|
3346
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
3347
|
+
/**
|
|
3348
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
3349
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
3350
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
3351
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
3352
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
3353
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
3354
|
+
* Mossbear-owned.
|
|
3355
|
+
*/
|
|
3356
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
3357
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3358
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
3359
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
3360
|
+
}, undefined>, undefined>;
|
|
3153
3361
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
3154
3362
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
3155
3363
|
/**
|
|
@@ -3272,6 +3480,30 @@ export declare const ItemCommentsResponseSchema: v.ObjectSchema<{
|
|
|
3272
3480
|
* strips this field never receives a draft it would print as a request.
|
|
3273
3481
|
*/
|
|
3274
3482
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
3483
|
+
/**
|
|
3484
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
3485
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
3486
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
3487
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
3488
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
3489
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
3490
|
+
* which already says open or resolved.
|
|
3491
|
+
*/
|
|
3492
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
3493
|
+
/**
|
|
3494
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
3495
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
3496
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
3497
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
3498
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
3499
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
3500
|
+
* Mossbear-owned.
|
|
3501
|
+
*/
|
|
3502
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
3503
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3504
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
3505
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
3506
|
+
}, undefined>, undefined>;
|
|
3275
3507
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
3276
3508
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
3277
3509
|
/**
|
|
@@ -3989,6 +4221,30 @@ export declare const ArtifactSchema: v.ObjectSchema<{
|
|
|
3989
4221
|
* strips this field never receives a draft it would print as a request.
|
|
3990
4222
|
*/
|
|
3991
4223
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
4224
|
+
/**
|
|
4225
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
4226
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
4227
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
4228
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
4229
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
4230
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
4231
|
+
* which already says open or resolved.
|
|
4232
|
+
*/
|
|
4233
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
4234
|
+
/**
|
|
4235
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
4236
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
4237
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
4238
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
4239
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
4240
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
4241
|
+
* Mossbear-owned.
|
|
4242
|
+
*/
|
|
4243
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
4244
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
4245
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
4246
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
4247
|
+
}, undefined>, undefined>;
|
|
3992
4248
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
3993
4249
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
3994
4250
|
/**
|
|
@@ -4074,6 +4330,12 @@ export declare const ArtifactSchema: v.ObjectSchema<{
|
|
|
4074
4330
|
prediction: string | null;
|
|
4075
4331
|
} | undefined;
|
|
4076
4332
|
approved?: boolean | undefined;
|
|
4333
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
4334
|
+
publishedFrom?: {
|
|
4335
|
+
projectId: string;
|
|
4336
|
+
branch: string | null;
|
|
4337
|
+
thisRepo?: boolean | undefined;
|
|
4338
|
+
} | undefined;
|
|
4077
4339
|
authorName: string | null;
|
|
4078
4340
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
4079
4341
|
createdAt: string;
|
|
@@ -4388,6 +4650,20 @@ export declare const CreateArtifactRequestSchema: v.StrictObjectSchema<{
|
|
|
4388
4650
|
*/
|
|
4389
4651
|
readonly identityKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "an identity key is letters, digits, `-` and `_`">]>, undefined>;
|
|
4390
4652
|
}, undefined>;
|
|
4653
|
+
/**
|
|
4654
|
+
* How an agent's content write was authored: `content` when the caller sent
|
|
4655
|
+
* the whole body, `edits` when it sent targeted replacements that the MCP
|
|
4656
|
+
* server applied before sending the resulting body. Either way the request
|
|
4657
|
+
* carries the full `content`, so this is the only record of which path was
|
|
4658
|
+
* taken. Provenance for counting how often each is used, stored in the saved
|
|
4659
|
+
* version's `metadata` and read back with the rest of it.
|
|
4660
|
+
*
|
|
4661
|
+
* A picklist so a later mode widens a vocabulary. Widening follows the
|
|
4662
|
+
* `harness` rule: the server is deployed first, since an id it does not know
|
|
4663
|
+
* rejects the whole update.
|
|
4664
|
+
*/
|
|
4665
|
+
export declare const ArtifactWriteModeSchema: v.PicklistSchema<["content", "edits"], undefined>;
|
|
4666
|
+
export type ArtifactWriteMode = v.InferOutput<typeof ArtifactWriteModeSchema>;
|
|
4391
4667
|
/**
|
|
4392
4668
|
* Update an existing artifact: its content, its name, its description, or a
|
|
4393
4669
|
* mix. The id is in the route. The version the caller read is required: there
|
|
@@ -4492,6 +4768,15 @@ export declare const UpdateArtifactRequestFieldsSchema: v.StrictObjectSchema<{
|
|
|
4492
4768
|
* and is not shown as authorship.
|
|
4493
4769
|
*/
|
|
4494
4770
|
readonly agentSessionId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>, undefined>;
|
|
4771
|
+
/**
|
|
4772
|
+
* Which path an agent's content write took ({@link ArtifactWriteModeSchema}),
|
|
4773
|
+
* recorded in the saved version's `metadata`. Sent only by the MCP server,
|
|
4774
|
+
* and absent from every other writer, which records none: absence means
|
|
4775
|
+
* "not known", never `content`. Provenance only. The route refuses it on a
|
|
4776
|
+
* request with no `content`, since a field edit saves no revision to record
|
|
4777
|
+
* it on.
|
|
4778
|
+
*/
|
|
4779
|
+
readonly writeMode: v.OptionalSchema<v.PicklistSchema<["content", "edits"], undefined>, undefined>;
|
|
4495
4780
|
/**
|
|
4496
4781
|
* A guide publication's members ({@link GuidePublishSchema}), written after
|
|
4497
4782
|
* the body. Accepted only on a guide's body, beside a `gitSource`.
|
|
@@ -4647,6 +4932,15 @@ export declare const UpdateArtifactRequestSchema: v.SchemaWithPipe<readonly [v.S
|
|
|
4647
4932
|
* and is not shown as authorship.
|
|
4648
4933
|
*/
|
|
4649
4934
|
readonly agentSessionId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>, undefined>;
|
|
4935
|
+
/**
|
|
4936
|
+
* Which path an agent's content write took ({@link ArtifactWriteModeSchema}),
|
|
4937
|
+
* recorded in the saved version's `metadata`. Sent only by the MCP server,
|
|
4938
|
+
* and absent from every other writer, which records none: absence means
|
|
4939
|
+
* "not known", never `content`. Provenance only. The route refuses it on a
|
|
4940
|
+
* request with no `content`, since a field edit saves no revision to record
|
|
4941
|
+
* it on.
|
|
4942
|
+
*/
|
|
4943
|
+
readonly writeMode: v.OptionalSchema<v.PicklistSchema<["content", "edits"], undefined>, undefined>;
|
|
4650
4944
|
/**
|
|
4651
4945
|
* A guide publication's members ({@link GuidePublishSchema}), written after
|
|
4652
4946
|
* the body. Accepted only on a guide's body, beside a `gitSource`.
|
|
@@ -4710,6 +5004,7 @@ export declare const UpdateArtifactRequestSchema: v.SchemaWithPipe<readonly [v.S
|
|
|
4710
5004
|
branch?: string | undefined;
|
|
4711
5005
|
} | undefined;
|
|
4712
5006
|
agentSessionId?: string | undefined;
|
|
5007
|
+
writeMode?: "content" | "edits" | undefined;
|
|
4713
5008
|
guide?: {
|
|
4714
5009
|
format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
|
|
4715
5010
|
members?: {
|
|
@@ -4915,6 +5210,30 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
|
|
|
4915
5210
|
* strips this field never receives a draft it would print as a request.
|
|
4916
5211
|
*/
|
|
4917
5212
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
5213
|
+
/**
|
|
5214
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
5215
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
5216
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
5217
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
5218
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
5219
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
5220
|
+
* which already says open or resolved.
|
|
5221
|
+
*/
|
|
5222
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
5223
|
+
/**
|
|
5224
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
5225
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
5226
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
5227
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
5228
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
5229
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
5230
|
+
* Mossbear-owned.
|
|
5231
|
+
*/
|
|
5232
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
5233
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
5234
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
5235
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
5236
|
+
}, undefined>, undefined>;
|
|
4918
5237
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
4919
5238
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
4920
5239
|
/**
|
|
@@ -5000,6 +5319,12 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5000
5319
|
prediction: string | null;
|
|
5001
5320
|
} | undefined;
|
|
5002
5321
|
approved?: boolean | undefined;
|
|
5322
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
5323
|
+
publishedFrom?: {
|
|
5324
|
+
projectId: string;
|
|
5325
|
+
branch: string | null;
|
|
5326
|
+
thisRepo?: boolean | undefined;
|
|
5327
|
+
} | undefined;
|
|
5003
5328
|
authorName: string | null;
|
|
5004
5329
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
5005
5330
|
createdAt: string;
|
|
@@ -5158,6 +5483,30 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5158
5483
|
* strips this field never receives a draft it would print as a request.
|
|
5159
5484
|
*/
|
|
5160
5485
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
5486
|
+
/**
|
|
5487
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
5488
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
5489
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
5490
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
5491
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
5492
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
5493
|
+
* which already says open or resolved.
|
|
5494
|
+
*/
|
|
5495
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
5496
|
+
/**
|
|
5497
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
5498
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
5499
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
5500
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
5501
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
5502
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
5503
|
+
* Mossbear-owned.
|
|
5504
|
+
*/
|
|
5505
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
5506
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
5507
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
5508
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
5509
|
+
}, undefined>, undefined>;
|
|
5161
5510
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
5162
5511
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5163
5512
|
/**
|
|
@@ -5243,6 +5592,12 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5243
5592
|
prediction: string | null;
|
|
5244
5593
|
} | undefined;
|
|
5245
5594
|
approved?: boolean | undefined;
|
|
5595
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
5596
|
+
publishedFrom?: {
|
|
5597
|
+
projectId: string;
|
|
5598
|
+
branch: string | null;
|
|
5599
|
+
thisRepo?: boolean | undefined;
|
|
5600
|
+
} | undefined;
|
|
5246
5601
|
authorName: string | null;
|
|
5247
5602
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
5248
5603
|
createdAt: string;
|
|
@@ -5365,6 +5720,30 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5365
5720
|
* strips this field never receives a draft it would print as a request.
|
|
5366
5721
|
*/
|
|
5367
5722
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
5723
|
+
/**
|
|
5724
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
5725
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
5726
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
5727
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
5728
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
5729
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
5730
|
+
* which already says open or resolved.
|
|
5731
|
+
*/
|
|
5732
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
5733
|
+
/**
|
|
5734
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
5735
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
5736
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
5737
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
5738
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
5739
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
5740
|
+
* Mossbear-owned.
|
|
5741
|
+
*/
|
|
5742
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
5743
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
5744
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
5745
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
5746
|
+
}, undefined>, undefined>;
|
|
5368
5747
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
5369
5748
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5370
5749
|
/**
|
|
@@ -5450,6 +5829,12 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5450
5829
|
prediction: string | null;
|
|
5451
5830
|
} | undefined;
|
|
5452
5831
|
approved?: boolean | undefined;
|
|
5832
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
5833
|
+
publishedFrom?: {
|
|
5834
|
+
projectId: string;
|
|
5835
|
+
branch: string | null;
|
|
5836
|
+
thisRepo?: boolean | undefined;
|
|
5837
|
+
} | undefined;
|
|
5453
5838
|
authorName: string | null;
|
|
5454
5839
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
5455
5840
|
createdAt: string;
|
|
@@ -5633,6 +6018,30 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
5633
6018
|
* strips this field never receives a draft it would print as a request.
|
|
5634
6019
|
*/
|
|
5635
6020
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6021
|
+
/**
|
|
6022
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
6023
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
6024
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
6025
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
6026
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
6027
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
6028
|
+
* which already says open or resolved.
|
|
6029
|
+
*/
|
|
6030
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
6031
|
+
/**
|
|
6032
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
6033
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
6034
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
6035
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
6036
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
6037
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
6038
|
+
* Mossbear-owned.
|
|
6039
|
+
*/
|
|
6040
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
6041
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
6042
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
6043
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6044
|
+
}, undefined>, undefined>;
|
|
5636
6045
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
5637
6046
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5638
6047
|
/**
|
|
@@ -5718,6 +6127,12 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
5718
6127
|
prediction: string | null;
|
|
5719
6128
|
} | undefined;
|
|
5720
6129
|
approved?: boolean | undefined;
|
|
6130
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
6131
|
+
publishedFrom?: {
|
|
6132
|
+
projectId: string;
|
|
6133
|
+
branch: string | null;
|
|
6134
|
+
thisRepo?: boolean | undefined;
|
|
6135
|
+
} | undefined;
|
|
5721
6136
|
authorName: string | null;
|
|
5722
6137
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
5723
6138
|
createdAt: string;
|
|
@@ -5856,6 +6271,30 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
|
|
|
5856
6271
|
* strips this field never receives a draft it would print as a request.
|
|
5857
6272
|
*/
|
|
5858
6273
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6274
|
+
/**
|
|
6275
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
6276
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
6277
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
6278
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
6279
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
6280
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
6281
|
+
* which already says open or resolved.
|
|
6282
|
+
*/
|
|
6283
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
6284
|
+
/**
|
|
6285
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
6286
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
6287
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
6288
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
6289
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
6290
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
6291
|
+
* Mossbear-owned.
|
|
6292
|
+
*/
|
|
6293
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
6294
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
6295
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
6296
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6297
|
+
}, undefined>, undefined>;
|
|
5859
6298
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
5860
6299
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5861
6300
|
/**
|
|
@@ -5941,6 +6380,12 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
|
|
|
5941
6380
|
prediction: string | null;
|
|
5942
6381
|
} | undefined;
|
|
5943
6382
|
approved?: boolean | undefined;
|
|
6383
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
6384
|
+
publishedFrom?: {
|
|
6385
|
+
projectId: string;
|
|
6386
|
+
branch: string | null;
|
|
6387
|
+
thisRepo?: boolean | undefined;
|
|
6388
|
+
} | undefined;
|
|
5944
6389
|
authorName: string | null;
|
|
5945
6390
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
5946
6391
|
createdAt: string;
|
|
@@ -6065,6 +6510,30 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
|
|
|
6065
6510
|
* strips this field never receives a draft it would print as a request.
|
|
6066
6511
|
*/
|
|
6067
6512
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6513
|
+
/**
|
|
6514
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
6515
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
6516
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
6517
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
6518
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
6519
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
6520
|
+
* which already says open or resolved.
|
|
6521
|
+
*/
|
|
6522
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
6523
|
+
/**
|
|
6524
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
6525
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
6526
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
6527
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
6528
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
6529
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
6530
|
+
* Mossbear-owned.
|
|
6531
|
+
*/
|
|
6532
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
6533
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
6534
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
6535
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6536
|
+
}, undefined>, undefined>;
|
|
6068
6537
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
6069
6538
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
6070
6539
|
/**
|
|
@@ -6150,6 +6619,12 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
|
|
|
6150
6619
|
prediction: string | null;
|
|
6151
6620
|
} | undefined;
|
|
6152
6621
|
approved?: boolean | undefined;
|
|
6622
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
6623
|
+
publishedFrom?: {
|
|
6624
|
+
projectId: string;
|
|
6625
|
+
branch: string | null;
|
|
6626
|
+
thisRepo?: boolean | undefined;
|
|
6627
|
+
} | undefined;
|
|
6153
6628
|
authorName: string | null;
|
|
6154
6629
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
6155
6630
|
createdAt: string;
|
|
@@ -6273,6 +6748,30 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
|
|
|
6273
6748
|
* strips this field never receives a draft it would print as a request.
|
|
6274
6749
|
*/
|
|
6275
6750
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6751
|
+
/**
|
|
6752
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
6753
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
6754
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
6755
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
6756
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
6757
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
6758
|
+
* which already says open or resolved.
|
|
6759
|
+
*/
|
|
6760
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
6761
|
+
/**
|
|
6762
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
6763
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
6764
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
6765
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
6766
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
6767
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
6768
|
+
* Mossbear-owned.
|
|
6769
|
+
*/
|
|
6770
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
6771
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
6772
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
6773
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6774
|
+
}, undefined>, undefined>;
|
|
6276
6775
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
6277
6776
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
6278
6777
|
/**
|
|
@@ -6358,6 +6857,12 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
|
|
|
6358
6857
|
prediction: string | null;
|
|
6359
6858
|
} | undefined;
|
|
6360
6859
|
approved?: boolean | undefined;
|
|
6860
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
6861
|
+
publishedFrom?: {
|
|
6862
|
+
projectId: string;
|
|
6863
|
+
branch: string | null;
|
|
6864
|
+
thisRepo?: boolean | undefined;
|
|
6865
|
+
} | undefined;
|
|
6361
6866
|
authorName: string | null;
|
|
6362
6867
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
6363
6868
|
createdAt: string;
|
|
@@ -6563,6 +7068,40 @@ export declare const UpsertArtifactDraftResponseSchema: v.ObjectSchema<{
|
|
|
6563
7068
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
6564
7069
|
}, undefined>, undefined>;
|
|
6565
7070
|
}, undefined>;
|
|
7071
|
+
/** Most revisions one retire call may carry; a longer range sends its newest. */
|
|
7072
|
+
export declare const MAX_LANDED_REVISIONS = 200;
|
|
7073
|
+
/**
|
|
7074
|
+
* One revision a published branch held between two publications: the sha256
|
|
7075
|
+
* of its UTF-8 text, as a draft's `contentHash` is, and the committer time of
|
|
7076
|
+
* the commit on the branch that replaced those bytes (the next commit that
|
|
7077
|
+
* touched the path, or the tip).
|
|
7078
|
+
*/
|
|
7079
|
+
export declare const LandedRevisionSchema: v.StrictObjectSchema<{
|
|
7080
|
+
readonly hash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
|
|
7081
|
+
readonly supersededAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
|
|
7082
|
+
}, undefined>;
|
|
7083
|
+
/**
|
|
7084
|
+
* Drafts of an artifact whose bytes a published branch held at some commit the
|
|
7085
|
+
* dashboard never received (the ref moved several commits between two
|
|
7086
|
+
* publications). The server cannot check the claim, so it retires only the
|
|
7087
|
+
* caller's own drafts, and only those last saved before the branch moved off
|
|
7088
|
+
* those bytes: a draft of the same bytes saved after is a new proposal.
|
|
7089
|
+
*/
|
|
7090
|
+
export declare const RetireArtifactDraftsRequestSchema: v.StrictObjectSchema<{
|
|
7091
|
+
readonly landedRevisions: v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
|
|
7092
|
+
readonly hash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
|
|
7093
|
+
readonly supersededAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
|
|
7094
|
+
}, undefined>, undefined>, v.MinLengthAction<{
|
|
7095
|
+
hash: string;
|
|
7096
|
+
supersededAt: string;
|
|
7097
|
+
}[], 1, undefined>, v.MaxLengthAction<{
|
|
7098
|
+
hash: string;
|
|
7099
|
+
supersededAt: string;
|
|
7100
|
+
}[], 200, undefined>]>;
|
|
7101
|
+
}, undefined>;
|
|
7102
|
+
export declare const RetireArtifactDraftsResponseSchema: v.ObjectSchema<{
|
|
7103
|
+
readonly retired: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
|
|
7104
|
+
}, undefined>;
|
|
6566
7105
|
/** The caller's own drafts of one artifact, most recently updated first. */
|
|
6567
7106
|
export declare const ListArtifactDraftsResponseSchema: v.ObjectSchema<{
|
|
6568
7107
|
readonly drafts: v.ArraySchema<v.ObjectSchema<{
|
|
@@ -8219,6 +8758,30 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
|
|
|
8219
8758
|
* strips this field never receives a draft it would print as a request.
|
|
8220
8759
|
*/
|
|
8221
8760
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
8761
|
+
/**
|
|
8762
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
8763
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
8764
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
8765
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
8766
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
8767
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
8768
|
+
* which already says open or resolved.
|
|
8769
|
+
*/
|
|
8770
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
8771
|
+
/**
|
|
8772
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
8773
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
8774
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
8775
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
8776
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
8777
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
8778
|
+
* Mossbear-owned.
|
|
8779
|
+
*/
|
|
8780
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
8781
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
8782
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
8783
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
8784
|
+
}, undefined>, undefined>;
|
|
8222
8785
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
8223
8786
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
8224
8787
|
/**
|
|
@@ -8555,6 +9118,30 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
|
|
|
8555
9118
|
* strips this field never receives a draft it would print as a request.
|
|
8556
9119
|
*/
|
|
8557
9120
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
9121
|
+
/**
|
|
9122
|
+
* Whether an open Mossbear finding is the agent's to act on. `ready` means the
|
|
9123
|
+
* person accepted it, or its evidence spans enough separate days to need no
|
|
9124
|
+
* Accept. `waiting` means it waits on the person: show it to the user and
|
|
9125
|
+
* change nothing unless they say so. Present only on an open Mossbear comment.
|
|
9126
|
+
* A server that predates the field omits it, and a reader then falls back to
|
|
9127
|
+
* `approved`. This is a new name rather than a new meaning for `state`,
|
|
9128
|
+
* which already says open or resolved.
|
|
9129
|
+
*/
|
|
9130
|
+
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
9131
|
+
/**
|
|
9132
|
+
* Where the artifact is published from, when Mossbear records one: the
|
|
9133
|
+
* committed `project.id` of the repository whose commits own it, and the
|
|
9134
|
+
* branch it was published from (null when none was recorded). `thisRepo` is
|
|
9135
|
+
* true when that is the repo the read declared, false when it is another repo,
|
|
9136
|
+
* and absent when the read declared no repo. The field is absent when Mossbear
|
|
9137
|
+
* records no publishing repo, which is not a claim that the artifact is
|
|
9138
|
+
* Mossbear-owned.
|
|
9139
|
+
*/
|
|
9140
|
+
readonly publishedFrom: v.OptionalSchema<v.ObjectSchema<{
|
|
9141
|
+
readonly projectId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
9142
|
+
readonly branch: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
9143
|
+
readonly thisRepo: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
9144
|
+
}, undefined>, undefined>;
|
|
8558
9145
|
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
8559
9146
|
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
8560
9147
|
/**
|
|
@@ -10353,6 +10940,12 @@ export declare function parseContextItemsResponse(data: unknown): {
|
|
|
10353
10940
|
prediction: string | null;
|
|
10354
10941
|
} | undefined;
|
|
10355
10942
|
approved?: boolean | undefined;
|
|
10943
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
10944
|
+
publishedFrom?: {
|
|
10945
|
+
projectId: string;
|
|
10946
|
+
branch: string | null;
|
|
10947
|
+
thisRepo?: boolean | undefined;
|
|
10948
|
+
} | undefined;
|
|
10356
10949
|
authorName: string | null;
|
|
10357
10950
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
10358
10951
|
createdAt: string;
|
|
@@ -10432,6 +11025,12 @@ export declare function parseBundleArtifactsResponse(data: unknown): {
|
|
|
10432
11025
|
prediction: string | null;
|
|
10433
11026
|
} | undefined;
|
|
10434
11027
|
approved?: boolean | undefined;
|
|
11028
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
11029
|
+
publishedFrom?: {
|
|
11030
|
+
projectId: string;
|
|
11031
|
+
branch: string | null;
|
|
11032
|
+
thisRepo?: boolean | undefined;
|
|
11033
|
+
} | undefined;
|
|
10435
11034
|
authorName: string | null;
|
|
10436
11035
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
10437
11036
|
createdAt: string;
|
|
@@ -10780,6 +11379,12 @@ export declare function parseItemCommentsResponse(data: unknown): {
|
|
|
10780
11379
|
prediction: string | null;
|
|
10781
11380
|
} | undefined;
|
|
10782
11381
|
approved?: boolean | undefined;
|
|
11382
|
+
findingState?: "ready" | "waiting" | undefined;
|
|
11383
|
+
publishedFrom?: {
|
|
11384
|
+
projectId: string;
|
|
11385
|
+
branch: string | null;
|
|
11386
|
+
thisRepo?: boolean | undefined;
|
|
11387
|
+
} | undefined;
|
|
10783
11388
|
authorName: string | null;
|
|
10784
11389
|
authorKind?: "person" | "agent" | "mossbear" | undefined;
|
|
10785
11390
|
createdAt: string;
|