@hol-org/rb-client 0.1.179 → 0.1.181
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/index.cjs +686 -71
- package/dist/index.d.cts +1681 -170
- package/dist/index.d.ts +1681 -170
- package/dist/index.js +684 -71
- package/package.json +1 -1
package/dist/index.d.cts
CHANGED
|
@@ -11824,24 +11824,36 @@ declare const guardBucketBalanceSchema: z.ZodObject<{
|
|
|
11824
11824
|
}>;
|
|
11825
11825
|
declare const guardPrincipalSchema: z.ZodObject<{
|
|
11826
11826
|
signedIn: z.ZodBoolean;
|
|
11827
|
+
principalType: z.ZodDefault<z.ZodEnum<["user", "service"]>>;
|
|
11827
11828
|
userId: z.ZodOptional<z.ZodString>;
|
|
11828
11829
|
email: z.ZodOptional<z.ZodString>;
|
|
11829
11830
|
accountId: z.ZodOptional<z.ZodString>;
|
|
11830
11831
|
stripeCustomerId: z.ZodOptional<z.ZodString>;
|
|
11832
|
+
serviceId: z.ZodOptional<z.ZodString>;
|
|
11833
|
+
workspaceId: z.ZodOptional<z.ZodString>;
|
|
11834
|
+
serviceLabel: z.ZodOptional<z.ZodString>;
|
|
11831
11835
|
roles: z.ZodArray<z.ZodString, "many">;
|
|
11832
11836
|
}, "strip", z.ZodTypeAny, {
|
|
11833
11837
|
accountId?: string;
|
|
11834
11838
|
userId?: string;
|
|
11835
11839
|
email?: string;
|
|
11836
11840
|
signedIn?: boolean;
|
|
11841
|
+
principalType?: "service" | "user";
|
|
11837
11842
|
stripeCustomerId?: string;
|
|
11843
|
+
serviceId?: string;
|
|
11844
|
+
workspaceId?: string;
|
|
11845
|
+
serviceLabel?: string;
|
|
11838
11846
|
roles?: string[];
|
|
11839
11847
|
}, {
|
|
11840
11848
|
accountId?: string;
|
|
11841
11849
|
userId?: string;
|
|
11842
11850
|
email?: string;
|
|
11843
11851
|
signedIn?: boolean;
|
|
11852
|
+
principalType?: "service" | "user";
|
|
11844
11853
|
stripeCustomerId?: string;
|
|
11854
|
+
serviceId?: string;
|
|
11855
|
+
workspaceId?: string;
|
|
11856
|
+
serviceLabel?: string;
|
|
11845
11857
|
roles?: string[];
|
|
11846
11858
|
}>;
|
|
11847
11859
|
declare const guardEntitlementsSchema: z.ZodObject<{
|
|
@@ -11872,24 +11884,36 @@ declare const guardEntitlementsSchema: z.ZodObject<{
|
|
|
11872
11884
|
declare const guardSessionResponseSchema: z.ZodObject<{
|
|
11873
11885
|
principal: z.ZodObject<{
|
|
11874
11886
|
signedIn: z.ZodBoolean;
|
|
11887
|
+
principalType: z.ZodDefault<z.ZodEnum<["user", "service"]>>;
|
|
11875
11888
|
userId: z.ZodOptional<z.ZodString>;
|
|
11876
11889
|
email: z.ZodOptional<z.ZodString>;
|
|
11877
11890
|
accountId: z.ZodOptional<z.ZodString>;
|
|
11878
11891
|
stripeCustomerId: z.ZodOptional<z.ZodString>;
|
|
11892
|
+
serviceId: z.ZodOptional<z.ZodString>;
|
|
11893
|
+
workspaceId: z.ZodOptional<z.ZodString>;
|
|
11894
|
+
serviceLabel: z.ZodOptional<z.ZodString>;
|
|
11879
11895
|
roles: z.ZodArray<z.ZodString, "many">;
|
|
11880
11896
|
}, "strip", z.ZodTypeAny, {
|
|
11881
11897
|
accountId?: string;
|
|
11882
11898
|
userId?: string;
|
|
11883
11899
|
email?: string;
|
|
11884
11900
|
signedIn?: boolean;
|
|
11901
|
+
principalType?: "service" | "user";
|
|
11885
11902
|
stripeCustomerId?: string;
|
|
11903
|
+
serviceId?: string;
|
|
11904
|
+
workspaceId?: string;
|
|
11905
|
+
serviceLabel?: string;
|
|
11886
11906
|
roles?: string[];
|
|
11887
11907
|
}, {
|
|
11888
11908
|
accountId?: string;
|
|
11889
11909
|
userId?: string;
|
|
11890
11910
|
email?: string;
|
|
11891
11911
|
signedIn?: boolean;
|
|
11912
|
+
principalType?: "service" | "user";
|
|
11892
11913
|
stripeCustomerId?: string;
|
|
11914
|
+
serviceId?: string;
|
|
11915
|
+
workspaceId?: string;
|
|
11916
|
+
serviceLabel?: string;
|
|
11893
11917
|
roles?: string[];
|
|
11894
11918
|
}>;
|
|
11895
11919
|
entitlements: z.ZodObject<{
|
|
@@ -11954,7 +11978,11 @@ declare const guardSessionResponseSchema: z.ZodObject<{
|
|
|
11954
11978
|
userId?: string;
|
|
11955
11979
|
email?: string;
|
|
11956
11980
|
signedIn?: boolean;
|
|
11981
|
+
principalType?: "service" | "user";
|
|
11957
11982
|
stripeCustomerId?: string;
|
|
11983
|
+
serviceId?: string;
|
|
11984
|
+
workspaceId?: string;
|
|
11985
|
+
serviceLabel?: string;
|
|
11958
11986
|
roles?: string[];
|
|
11959
11987
|
};
|
|
11960
11988
|
entitlements?: {
|
|
@@ -11983,7 +12011,11 @@ declare const guardSessionResponseSchema: z.ZodObject<{
|
|
|
11983
12011
|
userId?: string;
|
|
11984
12012
|
email?: string;
|
|
11985
12013
|
signedIn?: boolean;
|
|
12014
|
+
principalType?: "service" | "user";
|
|
11986
12015
|
stripeCustomerId?: string;
|
|
12016
|
+
serviceId?: string;
|
|
12017
|
+
workspaceId?: string;
|
|
12018
|
+
serviceLabel?: string;
|
|
11987
12019
|
roles?: string[];
|
|
11988
12020
|
};
|
|
11989
12021
|
entitlements?: {
|
|
@@ -12041,6 +12073,512 @@ declare const guardBalanceResponseSchema: z.ZodObject<{
|
|
|
12041
12073
|
}[];
|
|
12042
12074
|
generatedAt?: string;
|
|
12043
12075
|
}>;
|
|
12076
|
+
declare const guardFeedItemSchema: z.ZodObject<{
|
|
12077
|
+
id: z.ZodString;
|
|
12078
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
12079
|
+
slug: z.ZodString;
|
|
12080
|
+
name: z.ZodString;
|
|
12081
|
+
href: z.ZodString;
|
|
12082
|
+
ecosystem: z.ZodOptional<z.ZodString>;
|
|
12083
|
+
safetyScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
12084
|
+
trustScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
12085
|
+
verified: z.ZodBoolean;
|
|
12086
|
+
recommendation: z.ZodEnum<["monitor", "review", "block"]>;
|
|
12087
|
+
updatedAt: z.ZodString;
|
|
12088
|
+
}, "strip", z.ZodTypeAny, {
|
|
12089
|
+
name?: string;
|
|
12090
|
+
id?: string;
|
|
12091
|
+
updatedAt?: string;
|
|
12092
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12093
|
+
trustScore?: number;
|
|
12094
|
+
artifactType?: "skill" | "plugin";
|
|
12095
|
+
slug?: string;
|
|
12096
|
+
href?: string;
|
|
12097
|
+
ecosystem?: string;
|
|
12098
|
+
safetyScore?: number;
|
|
12099
|
+
verified?: boolean;
|
|
12100
|
+
}, {
|
|
12101
|
+
name?: string;
|
|
12102
|
+
id?: string;
|
|
12103
|
+
updatedAt?: string;
|
|
12104
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12105
|
+
trustScore?: number;
|
|
12106
|
+
artifactType?: "skill" | "plugin";
|
|
12107
|
+
slug?: string;
|
|
12108
|
+
href?: string;
|
|
12109
|
+
ecosystem?: string;
|
|
12110
|
+
safetyScore?: number;
|
|
12111
|
+
verified?: boolean;
|
|
12112
|
+
}>;
|
|
12113
|
+
declare const guardFeedSummarySchema: z.ZodObject<{
|
|
12114
|
+
total: z.ZodNumber;
|
|
12115
|
+
monitorCount: z.ZodNumber;
|
|
12116
|
+
reviewCount: z.ZodNumber;
|
|
12117
|
+
blockCount: z.ZodNumber;
|
|
12118
|
+
}, "strip", z.ZodTypeAny, {
|
|
12119
|
+
total?: number;
|
|
12120
|
+
monitorCount?: number;
|
|
12121
|
+
reviewCount?: number;
|
|
12122
|
+
blockCount?: number;
|
|
12123
|
+
}, {
|
|
12124
|
+
total?: number;
|
|
12125
|
+
monitorCount?: number;
|
|
12126
|
+
reviewCount?: number;
|
|
12127
|
+
blockCount?: number;
|
|
12128
|
+
}>;
|
|
12129
|
+
declare const guardFeedResponseSchema: z.ZodObject<{
|
|
12130
|
+
generatedAt: z.ZodString;
|
|
12131
|
+
items: z.ZodArray<z.ZodObject<{
|
|
12132
|
+
id: z.ZodString;
|
|
12133
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
12134
|
+
slug: z.ZodString;
|
|
12135
|
+
name: z.ZodString;
|
|
12136
|
+
href: z.ZodString;
|
|
12137
|
+
ecosystem: z.ZodOptional<z.ZodString>;
|
|
12138
|
+
safetyScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
12139
|
+
trustScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
12140
|
+
verified: z.ZodBoolean;
|
|
12141
|
+
recommendation: z.ZodEnum<["monitor", "review", "block"]>;
|
|
12142
|
+
updatedAt: z.ZodString;
|
|
12143
|
+
}, "strip", z.ZodTypeAny, {
|
|
12144
|
+
name?: string;
|
|
12145
|
+
id?: string;
|
|
12146
|
+
updatedAt?: string;
|
|
12147
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12148
|
+
trustScore?: number;
|
|
12149
|
+
artifactType?: "skill" | "plugin";
|
|
12150
|
+
slug?: string;
|
|
12151
|
+
href?: string;
|
|
12152
|
+
ecosystem?: string;
|
|
12153
|
+
safetyScore?: number;
|
|
12154
|
+
verified?: boolean;
|
|
12155
|
+
}, {
|
|
12156
|
+
name?: string;
|
|
12157
|
+
id?: string;
|
|
12158
|
+
updatedAt?: string;
|
|
12159
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12160
|
+
trustScore?: number;
|
|
12161
|
+
artifactType?: "skill" | "plugin";
|
|
12162
|
+
slug?: string;
|
|
12163
|
+
href?: string;
|
|
12164
|
+
ecosystem?: string;
|
|
12165
|
+
safetyScore?: number;
|
|
12166
|
+
verified?: boolean;
|
|
12167
|
+
}>, "many">;
|
|
12168
|
+
summary: z.ZodObject<{
|
|
12169
|
+
total: z.ZodNumber;
|
|
12170
|
+
monitorCount: z.ZodNumber;
|
|
12171
|
+
reviewCount: z.ZodNumber;
|
|
12172
|
+
blockCount: z.ZodNumber;
|
|
12173
|
+
}, "strip", z.ZodTypeAny, {
|
|
12174
|
+
total?: number;
|
|
12175
|
+
monitorCount?: number;
|
|
12176
|
+
reviewCount?: number;
|
|
12177
|
+
blockCount?: number;
|
|
12178
|
+
}, {
|
|
12179
|
+
total?: number;
|
|
12180
|
+
monitorCount?: number;
|
|
12181
|
+
reviewCount?: number;
|
|
12182
|
+
blockCount?: number;
|
|
12183
|
+
}>;
|
|
12184
|
+
}, "strip", z.ZodTypeAny, {
|
|
12185
|
+
summary?: {
|
|
12186
|
+
total?: number;
|
|
12187
|
+
monitorCount?: number;
|
|
12188
|
+
reviewCount?: number;
|
|
12189
|
+
blockCount?: number;
|
|
12190
|
+
};
|
|
12191
|
+
items?: {
|
|
12192
|
+
name?: string;
|
|
12193
|
+
id?: string;
|
|
12194
|
+
updatedAt?: string;
|
|
12195
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12196
|
+
trustScore?: number;
|
|
12197
|
+
artifactType?: "skill" | "plugin";
|
|
12198
|
+
slug?: string;
|
|
12199
|
+
href?: string;
|
|
12200
|
+
ecosystem?: string;
|
|
12201
|
+
safetyScore?: number;
|
|
12202
|
+
verified?: boolean;
|
|
12203
|
+
}[];
|
|
12204
|
+
generatedAt?: string;
|
|
12205
|
+
}, {
|
|
12206
|
+
summary?: {
|
|
12207
|
+
total?: number;
|
|
12208
|
+
monitorCount?: number;
|
|
12209
|
+
reviewCount?: number;
|
|
12210
|
+
blockCount?: number;
|
|
12211
|
+
};
|
|
12212
|
+
items?: {
|
|
12213
|
+
name?: string;
|
|
12214
|
+
id?: string;
|
|
12215
|
+
updatedAt?: string;
|
|
12216
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12217
|
+
trustScore?: number;
|
|
12218
|
+
artifactType?: "skill" | "plugin";
|
|
12219
|
+
slug?: string;
|
|
12220
|
+
href?: string;
|
|
12221
|
+
ecosystem?: string;
|
|
12222
|
+
safetyScore?: number;
|
|
12223
|
+
verified?: boolean;
|
|
12224
|
+
}[];
|
|
12225
|
+
generatedAt?: string;
|
|
12226
|
+
}>;
|
|
12227
|
+
declare const guardOverviewResponseSchema: z.ZodObject<{
|
|
12228
|
+
generatedAt: z.ZodString;
|
|
12229
|
+
principal: z.ZodObject<{
|
|
12230
|
+
signedIn: z.ZodBoolean;
|
|
12231
|
+
principalType: z.ZodDefault<z.ZodEnum<["user", "service"]>>;
|
|
12232
|
+
userId: z.ZodOptional<z.ZodString>;
|
|
12233
|
+
email: z.ZodOptional<z.ZodString>;
|
|
12234
|
+
accountId: z.ZodOptional<z.ZodString>;
|
|
12235
|
+
stripeCustomerId: z.ZodOptional<z.ZodString>;
|
|
12236
|
+
serviceId: z.ZodOptional<z.ZodString>;
|
|
12237
|
+
workspaceId: z.ZodOptional<z.ZodString>;
|
|
12238
|
+
serviceLabel: z.ZodOptional<z.ZodString>;
|
|
12239
|
+
roles: z.ZodArray<z.ZodString, "many">;
|
|
12240
|
+
}, "strip", z.ZodTypeAny, {
|
|
12241
|
+
accountId?: string;
|
|
12242
|
+
userId?: string;
|
|
12243
|
+
email?: string;
|
|
12244
|
+
signedIn?: boolean;
|
|
12245
|
+
principalType?: "service" | "user";
|
|
12246
|
+
stripeCustomerId?: string;
|
|
12247
|
+
serviceId?: string;
|
|
12248
|
+
workspaceId?: string;
|
|
12249
|
+
serviceLabel?: string;
|
|
12250
|
+
roles?: string[];
|
|
12251
|
+
}, {
|
|
12252
|
+
accountId?: string;
|
|
12253
|
+
userId?: string;
|
|
12254
|
+
email?: string;
|
|
12255
|
+
signedIn?: boolean;
|
|
12256
|
+
principalType?: "service" | "user";
|
|
12257
|
+
stripeCustomerId?: string;
|
|
12258
|
+
serviceId?: string;
|
|
12259
|
+
workspaceId?: string;
|
|
12260
|
+
serviceLabel?: string;
|
|
12261
|
+
roles?: string[];
|
|
12262
|
+
}>;
|
|
12263
|
+
entitlements: z.ZodObject<{
|
|
12264
|
+
planId: z.ZodEnum<["free", "pro", "team", "enterprise"]>;
|
|
12265
|
+
includedMonthlyCredits: z.ZodNumber;
|
|
12266
|
+
deviceLimit: z.ZodNumber;
|
|
12267
|
+
retentionDays: z.ZodNumber;
|
|
12268
|
+
syncEnabled: z.ZodBoolean;
|
|
12269
|
+
premiumFeedsEnabled: z.ZodBoolean;
|
|
12270
|
+
teamPolicyEnabled: z.ZodBoolean;
|
|
12271
|
+
}, "strip", z.ZodTypeAny, {
|
|
12272
|
+
includedMonthlyCredits?: number;
|
|
12273
|
+
planId?: "free" | "pro" | "team" | "enterprise";
|
|
12274
|
+
deviceLimit?: number;
|
|
12275
|
+
retentionDays?: number;
|
|
12276
|
+
syncEnabled?: boolean;
|
|
12277
|
+
premiumFeedsEnabled?: boolean;
|
|
12278
|
+
teamPolicyEnabled?: boolean;
|
|
12279
|
+
}, {
|
|
12280
|
+
includedMonthlyCredits?: number;
|
|
12281
|
+
planId?: "free" | "pro" | "team" | "enterprise";
|
|
12282
|
+
deviceLimit?: number;
|
|
12283
|
+
retentionDays?: number;
|
|
12284
|
+
syncEnabled?: boolean;
|
|
12285
|
+
premiumFeedsEnabled?: boolean;
|
|
12286
|
+
teamPolicyEnabled?: boolean;
|
|
12287
|
+
}>;
|
|
12288
|
+
balance: z.ZodNullable<z.ZodObject<{
|
|
12289
|
+
accountId: z.ZodString;
|
|
12290
|
+
availableCredits: z.ZodNumber;
|
|
12291
|
+
}, "strip", z.ZodTypeAny, {
|
|
12292
|
+
accountId?: string;
|
|
12293
|
+
availableCredits?: number;
|
|
12294
|
+
}, {
|
|
12295
|
+
accountId?: string;
|
|
12296
|
+
availableCredits?: number;
|
|
12297
|
+
}>>;
|
|
12298
|
+
trustFeed: z.ZodObject<{
|
|
12299
|
+
generatedAt: z.ZodString;
|
|
12300
|
+
items: z.ZodArray<z.ZodObject<{
|
|
12301
|
+
id: z.ZodString;
|
|
12302
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
12303
|
+
slug: z.ZodString;
|
|
12304
|
+
name: z.ZodString;
|
|
12305
|
+
href: z.ZodString;
|
|
12306
|
+
ecosystem: z.ZodOptional<z.ZodString>;
|
|
12307
|
+
safetyScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
12308
|
+
trustScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
12309
|
+
verified: z.ZodBoolean;
|
|
12310
|
+
recommendation: z.ZodEnum<["monitor", "review", "block"]>;
|
|
12311
|
+
updatedAt: z.ZodString;
|
|
12312
|
+
}, "strip", z.ZodTypeAny, {
|
|
12313
|
+
name?: string;
|
|
12314
|
+
id?: string;
|
|
12315
|
+
updatedAt?: string;
|
|
12316
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12317
|
+
trustScore?: number;
|
|
12318
|
+
artifactType?: "skill" | "plugin";
|
|
12319
|
+
slug?: string;
|
|
12320
|
+
href?: string;
|
|
12321
|
+
ecosystem?: string;
|
|
12322
|
+
safetyScore?: number;
|
|
12323
|
+
verified?: boolean;
|
|
12324
|
+
}, {
|
|
12325
|
+
name?: string;
|
|
12326
|
+
id?: string;
|
|
12327
|
+
updatedAt?: string;
|
|
12328
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12329
|
+
trustScore?: number;
|
|
12330
|
+
artifactType?: "skill" | "plugin";
|
|
12331
|
+
slug?: string;
|
|
12332
|
+
href?: string;
|
|
12333
|
+
ecosystem?: string;
|
|
12334
|
+
safetyScore?: number;
|
|
12335
|
+
verified?: boolean;
|
|
12336
|
+
}>, "many">;
|
|
12337
|
+
summary: z.ZodObject<{
|
|
12338
|
+
total: z.ZodNumber;
|
|
12339
|
+
monitorCount: z.ZodNumber;
|
|
12340
|
+
reviewCount: z.ZodNumber;
|
|
12341
|
+
blockCount: z.ZodNumber;
|
|
12342
|
+
}, "strip", z.ZodTypeAny, {
|
|
12343
|
+
total?: number;
|
|
12344
|
+
monitorCount?: number;
|
|
12345
|
+
reviewCount?: number;
|
|
12346
|
+
blockCount?: number;
|
|
12347
|
+
}, {
|
|
12348
|
+
total?: number;
|
|
12349
|
+
monitorCount?: number;
|
|
12350
|
+
reviewCount?: number;
|
|
12351
|
+
blockCount?: number;
|
|
12352
|
+
}>;
|
|
12353
|
+
}, "strip", z.ZodTypeAny, {
|
|
12354
|
+
summary?: {
|
|
12355
|
+
total?: number;
|
|
12356
|
+
monitorCount?: number;
|
|
12357
|
+
reviewCount?: number;
|
|
12358
|
+
blockCount?: number;
|
|
12359
|
+
};
|
|
12360
|
+
items?: {
|
|
12361
|
+
name?: string;
|
|
12362
|
+
id?: string;
|
|
12363
|
+
updatedAt?: string;
|
|
12364
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12365
|
+
trustScore?: number;
|
|
12366
|
+
artifactType?: "skill" | "plugin";
|
|
12367
|
+
slug?: string;
|
|
12368
|
+
href?: string;
|
|
12369
|
+
ecosystem?: string;
|
|
12370
|
+
safetyScore?: number;
|
|
12371
|
+
verified?: boolean;
|
|
12372
|
+
}[];
|
|
12373
|
+
generatedAt?: string;
|
|
12374
|
+
}, {
|
|
12375
|
+
summary?: {
|
|
12376
|
+
total?: number;
|
|
12377
|
+
monitorCount?: number;
|
|
12378
|
+
reviewCount?: number;
|
|
12379
|
+
blockCount?: number;
|
|
12380
|
+
};
|
|
12381
|
+
items?: {
|
|
12382
|
+
name?: string;
|
|
12383
|
+
id?: string;
|
|
12384
|
+
updatedAt?: string;
|
|
12385
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12386
|
+
trustScore?: number;
|
|
12387
|
+
artifactType?: "skill" | "plugin";
|
|
12388
|
+
slug?: string;
|
|
12389
|
+
href?: string;
|
|
12390
|
+
ecosystem?: string;
|
|
12391
|
+
safetyScore?: number;
|
|
12392
|
+
verified?: boolean;
|
|
12393
|
+
}[];
|
|
12394
|
+
generatedAt?: string;
|
|
12395
|
+
}>;
|
|
12396
|
+
integrations: z.ZodArray<z.ZodObject<{
|
|
12397
|
+
id: z.ZodEnum<["openclaw", "hermes"]>;
|
|
12398
|
+
name: z.ZodString;
|
|
12399
|
+
status: z.ZodEnum<["available", "planned"]>;
|
|
12400
|
+
href: z.ZodNullable<z.ZodString>;
|
|
12401
|
+
summary: z.ZodString;
|
|
12402
|
+
}, "strip", z.ZodTypeAny, {
|
|
12403
|
+
name?: string;
|
|
12404
|
+
status?: "available" | "planned";
|
|
12405
|
+
id?: "openclaw" | "hermes";
|
|
12406
|
+
summary?: string;
|
|
12407
|
+
href?: string;
|
|
12408
|
+
}, {
|
|
12409
|
+
name?: string;
|
|
12410
|
+
status?: "available" | "planned";
|
|
12411
|
+
id?: "openclaw" | "hermes";
|
|
12412
|
+
summary?: string;
|
|
12413
|
+
href?: string;
|
|
12414
|
+
}>, "many">;
|
|
12415
|
+
actionItems: z.ZodArray<z.ZodObject<{
|
|
12416
|
+
title: z.ZodString;
|
|
12417
|
+
description: z.ZodString;
|
|
12418
|
+
href: z.ZodString;
|
|
12419
|
+
}, "strip", z.ZodTypeAny, {
|
|
12420
|
+
description?: string;
|
|
12421
|
+
title?: string;
|
|
12422
|
+
href?: string;
|
|
12423
|
+
}, {
|
|
12424
|
+
description?: string;
|
|
12425
|
+
title?: string;
|
|
12426
|
+
href?: string;
|
|
12427
|
+
}>, "many">;
|
|
12428
|
+
}, "strip", z.ZodTypeAny, {
|
|
12429
|
+
balance?: {
|
|
12430
|
+
accountId?: string;
|
|
12431
|
+
availableCredits?: number;
|
|
12432
|
+
};
|
|
12433
|
+
principal?: {
|
|
12434
|
+
accountId?: string;
|
|
12435
|
+
userId?: string;
|
|
12436
|
+
email?: string;
|
|
12437
|
+
signedIn?: boolean;
|
|
12438
|
+
principalType?: "service" | "user";
|
|
12439
|
+
stripeCustomerId?: string;
|
|
12440
|
+
serviceId?: string;
|
|
12441
|
+
workspaceId?: string;
|
|
12442
|
+
serviceLabel?: string;
|
|
12443
|
+
roles?: string[];
|
|
12444
|
+
};
|
|
12445
|
+
entitlements?: {
|
|
12446
|
+
includedMonthlyCredits?: number;
|
|
12447
|
+
planId?: "free" | "pro" | "team" | "enterprise";
|
|
12448
|
+
deviceLimit?: number;
|
|
12449
|
+
retentionDays?: number;
|
|
12450
|
+
syncEnabled?: boolean;
|
|
12451
|
+
premiumFeedsEnabled?: boolean;
|
|
12452
|
+
teamPolicyEnabled?: boolean;
|
|
12453
|
+
};
|
|
12454
|
+
generatedAt?: string;
|
|
12455
|
+
trustFeed?: {
|
|
12456
|
+
summary?: {
|
|
12457
|
+
total?: number;
|
|
12458
|
+
monitorCount?: number;
|
|
12459
|
+
reviewCount?: number;
|
|
12460
|
+
blockCount?: number;
|
|
12461
|
+
};
|
|
12462
|
+
items?: {
|
|
12463
|
+
name?: string;
|
|
12464
|
+
id?: string;
|
|
12465
|
+
updatedAt?: string;
|
|
12466
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12467
|
+
trustScore?: number;
|
|
12468
|
+
artifactType?: "skill" | "plugin";
|
|
12469
|
+
slug?: string;
|
|
12470
|
+
href?: string;
|
|
12471
|
+
ecosystem?: string;
|
|
12472
|
+
safetyScore?: number;
|
|
12473
|
+
verified?: boolean;
|
|
12474
|
+
}[];
|
|
12475
|
+
generatedAt?: string;
|
|
12476
|
+
};
|
|
12477
|
+
integrations?: {
|
|
12478
|
+
name?: string;
|
|
12479
|
+
status?: "available" | "planned";
|
|
12480
|
+
id?: "openclaw" | "hermes";
|
|
12481
|
+
summary?: string;
|
|
12482
|
+
href?: string;
|
|
12483
|
+
}[];
|
|
12484
|
+
actionItems?: {
|
|
12485
|
+
description?: string;
|
|
12486
|
+
title?: string;
|
|
12487
|
+
href?: string;
|
|
12488
|
+
}[];
|
|
12489
|
+
}, {
|
|
12490
|
+
balance?: {
|
|
12491
|
+
accountId?: string;
|
|
12492
|
+
availableCredits?: number;
|
|
12493
|
+
};
|
|
12494
|
+
principal?: {
|
|
12495
|
+
accountId?: string;
|
|
12496
|
+
userId?: string;
|
|
12497
|
+
email?: string;
|
|
12498
|
+
signedIn?: boolean;
|
|
12499
|
+
principalType?: "service" | "user";
|
|
12500
|
+
stripeCustomerId?: string;
|
|
12501
|
+
serviceId?: string;
|
|
12502
|
+
workspaceId?: string;
|
|
12503
|
+
serviceLabel?: string;
|
|
12504
|
+
roles?: string[];
|
|
12505
|
+
};
|
|
12506
|
+
entitlements?: {
|
|
12507
|
+
includedMonthlyCredits?: number;
|
|
12508
|
+
planId?: "free" | "pro" | "team" | "enterprise";
|
|
12509
|
+
deviceLimit?: number;
|
|
12510
|
+
retentionDays?: number;
|
|
12511
|
+
syncEnabled?: boolean;
|
|
12512
|
+
premiumFeedsEnabled?: boolean;
|
|
12513
|
+
teamPolicyEnabled?: boolean;
|
|
12514
|
+
};
|
|
12515
|
+
generatedAt?: string;
|
|
12516
|
+
trustFeed?: {
|
|
12517
|
+
summary?: {
|
|
12518
|
+
total?: number;
|
|
12519
|
+
monitorCount?: number;
|
|
12520
|
+
reviewCount?: number;
|
|
12521
|
+
blockCount?: number;
|
|
12522
|
+
};
|
|
12523
|
+
items?: {
|
|
12524
|
+
name?: string;
|
|
12525
|
+
id?: string;
|
|
12526
|
+
updatedAt?: string;
|
|
12527
|
+
recommendation?: "monitor" | "review" | "block";
|
|
12528
|
+
trustScore?: number;
|
|
12529
|
+
artifactType?: "skill" | "plugin";
|
|
12530
|
+
slug?: string;
|
|
12531
|
+
href?: string;
|
|
12532
|
+
ecosystem?: string;
|
|
12533
|
+
safetyScore?: number;
|
|
12534
|
+
verified?: boolean;
|
|
12535
|
+
}[];
|
|
12536
|
+
generatedAt?: string;
|
|
12537
|
+
};
|
|
12538
|
+
integrations?: {
|
|
12539
|
+
name?: string;
|
|
12540
|
+
status?: "available" | "planned";
|
|
12541
|
+
id?: "openclaw" | "hermes";
|
|
12542
|
+
summary?: string;
|
|
12543
|
+
href?: string;
|
|
12544
|
+
}[];
|
|
12545
|
+
actionItems?: {
|
|
12546
|
+
description?: string;
|
|
12547
|
+
title?: string;
|
|
12548
|
+
href?: string;
|
|
12549
|
+
}[];
|
|
12550
|
+
}>;
|
|
12551
|
+
declare const guardPolicySchema: z.ZodObject<{
|
|
12552
|
+
mode: z.ZodEnum<["observe", "prompt", "enforce"]>;
|
|
12553
|
+
defaultAction: z.ZodEnum<["allow", "warn", "block"]>;
|
|
12554
|
+
unknownPublisherAction: z.ZodEnum<["review", "block", "allow"]>;
|
|
12555
|
+
changedHashAction: z.ZodEnum<["allow", "warn", "require-reapproval", "block"]>;
|
|
12556
|
+
newNetworkDomainAction: z.ZodEnum<["allow", "warn", "block"]>;
|
|
12557
|
+
subprocessAction: z.ZodEnum<["allow", "warn", "block"]>;
|
|
12558
|
+
telemetryEnabled: z.ZodBoolean;
|
|
12559
|
+
syncEnabled: z.ZodBoolean;
|
|
12560
|
+
updatedAt: z.ZodString;
|
|
12561
|
+
}, "strip", z.ZodTypeAny, {
|
|
12562
|
+
mode?: "observe" | "prompt" | "enforce";
|
|
12563
|
+
updatedAt?: string;
|
|
12564
|
+
syncEnabled?: boolean;
|
|
12565
|
+
defaultAction?: "warn" | "block" | "allow";
|
|
12566
|
+
unknownPublisherAction?: "review" | "block" | "allow";
|
|
12567
|
+
changedHashAction?: "warn" | "block" | "allow" | "require-reapproval";
|
|
12568
|
+
newNetworkDomainAction?: "warn" | "block" | "allow";
|
|
12569
|
+
subprocessAction?: "warn" | "block" | "allow";
|
|
12570
|
+
telemetryEnabled?: boolean;
|
|
12571
|
+
}, {
|
|
12572
|
+
mode?: "observe" | "prompt" | "enforce";
|
|
12573
|
+
updatedAt?: string;
|
|
12574
|
+
syncEnabled?: boolean;
|
|
12575
|
+
defaultAction?: "warn" | "block" | "allow";
|
|
12576
|
+
unknownPublisherAction?: "review" | "block" | "allow";
|
|
12577
|
+
changedHashAction?: "warn" | "block" | "allow" | "require-reapproval";
|
|
12578
|
+
newNetworkDomainAction?: "warn" | "block" | "allow";
|
|
12579
|
+
subprocessAction?: "warn" | "block" | "allow";
|
|
12580
|
+
telemetryEnabled?: boolean;
|
|
12581
|
+
}>;
|
|
12044
12582
|
declare const guardTrustMatchSchema: z.ZodObject<{
|
|
12045
12583
|
artifactId: z.ZodString;
|
|
12046
12584
|
artifactName: z.ZodString;
|
|
@@ -12055,25 +12593,25 @@ declare const guardTrustMatchSchema: z.ZodObject<{
|
|
|
12055
12593
|
}, "strip", z.ZodTypeAny, {
|
|
12056
12594
|
recommendation?: "monitor" | "review" | "block";
|
|
12057
12595
|
trustScore?: number;
|
|
12058
|
-
artifactId?: string;
|
|
12059
|
-
artifactName?: string;
|
|
12060
12596
|
artifactType?: "skill" | "plugin";
|
|
12061
|
-
artifactSlug?: string;
|
|
12062
|
-
verified?: boolean;
|
|
12063
|
-
safetyScore?: number;
|
|
12064
12597
|
href?: string;
|
|
12065
12598
|
ecosystem?: string;
|
|
12599
|
+
safetyScore?: number;
|
|
12600
|
+
verified?: boolean;
|
|
12601
|
+
artifactId?: string;
|
|
12602
|
+
artifactName?: string;
|
|
12603
|
+
artifactSlug?: string;
|
|
12066
12604
|
}, {
|
|
12067
12605
|
recommendation?: "monitor" | "review" | "block";
|
|
12068
12606
|
trustScore?: number;
|
|
12069
|
-
artifactId?: string;
|
|
12070
|
-
artifactName?: string;
|
|
12071
12607
|
artifactType?: "skill" | "plugin";
|
|
12072
|
-
artifactSlug?: string;
|
|
12073
|
-
verified?: boolean;
|
|
12074
|
-
safetyScore?: number;
|
|
12075
12608
|
href?: string;
|
|
12076
12609
|
ecosystem?: string;
|
|
12610
|
+
safetyScore?: number;
|
|
12611
|
+
verified?: boolean;
|
|
12612
|
+
artifactId?: string;
|
|
12613
|
+
artifactName?: string;
|
|
12614
|
+
artifactSlug?: string;
|
|
12077
12615
|
}>;
|
|
12078
12616
|
declare const guardTrustByHashResponseSchema: z.ZodObject<{
|
|
12079
12617
|
generatedAt: z.ZodString;
|
|
@@ -12098,39 +12636,39 @@ declare const guardTrustByHashResponseSchema: z.ZodObject<{
|
|
|
12098
12636
|
}, "strip", z.ZodTypeAny, {
|
|
12099
12637
|
recommendation?: "monitor" | "review" | "block";
|
|
12100
12638
|
trustScore?: number;
|
|
12101
|
-
artifactId?: string;
|
|
12102
|
-
artifactName?: string;
|
|
12103
12639
|
artifactType?: "skill" | "plugin";
|
|
12104
|
-
artifactSlug?: string;
|
|
12105
|
-
verified?: boolean;
|
|
12106
|
-
safetyScore?: number;
|
|
12107
12640
|
href?: string;
|
|
12108
12641
|
ecosystem?: string;
|
|
12642
|
+
safetyScore?: number;
|
|
12643
|
+
verified?: boolean;
|
|
12644
|
+
artifactId?: string;
|
|
12645
|
+
artifactName?: string;
|
|
12646
|
+
artifactSlug?: string;
|
|
12109
12647
|
}, {
|
|
12110
12648
|
recommendation?: "monitor" | "review" | "block";
|
|
12111
12649
|
trustScore?: number;
|
|
12112
|
-
artifactId?: string;
|
|
12113
|
-
artifactName?: string;
|
|
12114
12650
|
artifactType?: "skill" | "plugin";
|
|
12115
|
-
artifactSlug?: string;
|
|
12116
|
-
verified?: boolean;
|
|
12117
|
-
safetyScore?: number;
|
|
12118
12651
|
href?: string;
|
|
12119
12652
|
ecosystem?: string;
|
|
12653
|
+
safetyScore?: number;
|
|
12654
|
+
verified?: boolean;
|
|
12655
|
+
artifactId?: string;
|
|
12656
|
+
artifactName?: string;
|
|
12657
|
+
artifactSlug?: string;
|
|
12120
12658
|
}>>;
|
|
12121
12659
|
evidence: z.ZodArray<z.ZodString, "many">;
|
|
12122
12660
|
}, "strip", z.ZodTypeAny, {
|
|
12123
12661
|
match?: {
|
|
12124
12662
|
recommendation?: "monitor" | "review" | "block";
|
|
12125
12663
|
trustScore?: number;
|
|
12126
|
-
artifactId?: string;
|
|
12127
|
-
artifactName?: string;
|
|
12128
12664
|
artifactType?: "skill" | "plugin";
|
|
12129
|
-
artifactSlug?: string;
|
|
12130
|
-
verified?: boolean;
|
|
12131
|
-
safetyScore?: number;
|
|
12132
12665
|
href?: string;
|
|
12133
12666
|
ecosystem?: string;
|
|
12667
|
+
safetyScore?: number;
|
|
12668
|
+
verified?: boolean;
|
|
12669
|
+
artifactId?: string;
|
|
12670
|
+
artifactName?: string;
|
|
12671
|
+
artifactSlug?: string;
|
|
12134
12672
|
};
|
|
12135
12673
|
query?: {
|
|
12136
12674
|
sha256?: string;
|
|
@@ -12141,14 +12679,14 @@ declare const guardTrustByHashResponseSchema: z.ZodObject<{
|
|
|
12141
12679
|
match?: {
|
|
12142
12680
|
recommendation?: "monitor" | "review" | "block";
|
|
12143
12681
|
trustScore?: number;
|
|
12144
|
-
artifactId?: string;
|
|
12145
|
-
artifactName?: string;
|
|
12146
12682
|
artifactType?: "skill" | "plugin";
|
|
12147
|
-
artifactSlug?: string;
|
|
12148
|
-
verified?: boolean;
|
|
12149
|
-
safetyScore?: number;
|
|
12150
12683
|
href?: string;
|
|
12151
12684
|
ecosystem?: string;
|
|
12685
|
+
safetyScore?: number;
|
|
12686
|
+
verified?: boolean;
|
|
12687
|
+
artifactId?: string;
|
|
12688
|
+
artifactName?: string;
|
|
12689
|
+
artifactSlug?: string;
|
|
12152
12690
|
};
|
|
12153
12691
|
query?: {
|
|
12154
12692
|
sha256?: string;
|
|
@@ -12185,38 +12723,38 @@ declare const guardTrustResolveResponseSchema: z.ZodObject<{
|
|
|
12185
12723
|
}, "strip", z.ZodTypeAny, {
|
|
12186
12724
|
recommendation?: "monitor" | "review" | "block";
|
|
12187
12725
|
trustScore?: number;
|
|
12188
|
-
artifactId?: string;
|
|
12189
|
-
artifactName?: string;
|
|
12190
12726
|
artifactType?: "skill" | "plugin";
|
|
12191
|
-
artifactSlug?: string;
|
|
12192
|
-
verified?: boolean;
|
|
12193
|
-
safetyScore?: number;
|
|
12194
12727
|
href?: string;
|
|
12195
12728
|
ecosystem?: string;
|
|
12729
|
+
safetyScore?: number;
|
|
12730
|
+
verified?: boolean;
|
|
12731
|
+
artifactId?: string;
|
|
12732
|
+
artifactName?: string;
|
|
12733
|
+
artifactSlug?: string;
|
|
12196
12734
|
}, {
|
|
12197
12735
|
recommendation?: "monitor" | "review" | "block";
|
|
12198
12736
|
trustScore?: number;
|
|
12199
|
-
artifactId?: string;
|
|
12200
|
-
artifactName?: string;
|
|
12201
12737
|
artifactType?: "skill" | "plugin";
|
|
12202
|
-
artifactSlug?: string;
|
|
12203
|
-
verified?: boolean;
|
|
12204
|
-
safetyScore?: number;
|
|
12205
12738
|
href?: string;
|
|
12206
12739
|
ecosystem?: string;
|
|
12740
|
+
safetyScore?: number;
|
|
12741
|
+
verified?: boolean;
|
|
12742
|
+
artifactId?: string;
|
|
12743
|
+
artifactName?: string;
|
|
12744
|
+
artifactSlug?: string;
|
|
12207
12745
|
}>, "many">;
|
|
12208
12746
|
}, "strip", z.ZodTypeAny, {
|
|
12209
12747
|
items?: {
|
|
12210
12748
|
recommendation?: "monitor" | "review" | "block";
|
|
12211
12749
|
trustScore?: number;
|
|
12212
|
-
artifactId?: string;
|
|
12213
|
-
artifactName?: string;
|
|
12214
12750
|
artifactType?: "skill" | "plugin";
|
|
12215
|
-
artifactSlug?: string;
|
|
12216
|
-
verified?: boolean;
|
|
12217
|
-
safetyScore?: number;
|
|
12218
12751
|
href?: string;
|
|
12219
12752
|
ecosystem?: string;
|
|
12753
|
+
safetyScore?: number;
|
|
12754
|
+
verified?: boolean;
|
|
12755
|
+
artifactId?: string;
|
|
12756
|
+
artifactName?: string;
|
|
12757
|
+
artifactSlug?: string;
|
|
12220
12758
|
}[];
|
|
12221
12759
|
query?: {
|
|
12222
12760
|
name?: string;
|
|
@@ -12228,14 +12766,14 @@ declare const guardTrustResolveResponseSchema: z.ZodObject<{
|
|
|
12228
12766
|
items?: {
|
|
12229
12767
|
recommendation?: "monitor" | "review" | "block";
|
|
12230
12768
|
trustScore?: number;
|
|
12231
|
-
artifactId?: string;
|
|
12232
|
-
artifactName?: string;
|
|
12233
12769
|
artifactType?: "skill" | "plugin";
|
|
12234
|
-
artifactSlug?: string;
|
|
12235
|
-
verified?: boolean;
|
|
12236
|
-
safetyScore?: number;
|
|
12237
12770
|
href?: string;
|
|
12238
12771
|
ecosystem?: string;
|
|
12772
|
+
safetyScore?: number;
|
|
12773
|
+
verified?: boolean;
|
|
12774
|
+
artifactId?: string;
|
|
12775
|
+
artifactName?: string;
|
|
12776
|
+
artifactSlug?: string;
|
|
12239
12777
|
}[];
|
|
12240
12778
|
query?: {
|
|
12241
12779
|
name?: string;
|
|
@@ -12253,39 +12791,69 @@ declare const guardRevocationResponseSchema: z.ZodObject<{
|
|
|
12253
12791
|
reason: z.ZodString;
|
|
12254
12792
|
severity: z.ZodEnum<["low", "medium", "high"]>;
|
|
12255
12793
|
publishedAt: z.ZodString;
|
|
12794
|
+
confidence: z.ZodOptional<z.ZodNumber>;
|
|
12795
|
+
remediation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
12796
|
+
scope: z.ZodOptional<z.ZodEnum<["artifact", "publisher", "domain", "workspace", "ecosystem"]>>;
|
|
12797
|
+
source: z.ZodOptional<z.ZodString>;
|
|
12798
|
+
firstSeenAt: z.ZodOptional<z.ZodString>;
|
|
12799
|
+
lastUpdatedAt: z.ZodOptional<z.ZodString>;
|
|
12256
12800
|
}, "strip", z.ZodTypeAny, {
|
|
12257
12801
|
reason?: string;
|
|
12258
12802
|
id?: string;
|
|
12803
|
+
confidence?: number;
|
|
12259
12804
|
artifactId?: string;
|
|
12260
12805
|
artifactName?: string;
|
|
12261
12806
|
severity?: "low" | "medium" | "high";
|
|
12262
12807
|
publishedAt?: string;
|
|
12808
|
+
remediation?: string;
|
|
12809
|
+
scope?: "domain" | "ecosystem" | "artifact" | "publisher" | "workspace";
|
|
12810
|
+
source?: string;
|
|
12811
|
+
firstSeenAt?: string;
|
|
12812
|
+
lastUpdatedAt?: string;
|
|
12263
12813
|
}, {
|
|
12264
12814
|
reason?: string;
|
|
12265
12815
|
id?: string;
|
|
12816
|
+
confidence?: number;
|
|
12266
12817
|
artifactId?: string;
|
|
12267
12818
|
artifactName?: string;
|
|
12268
12819
|
severity?: "low" | "medium" | "high";
|
|
12269
12820
|
publishedAt?: string;
|
|
12821
|
+
remediation?: string;
|
|
12822
|
+
scope?: "domain" | "ecosystem" | "artifact" | "publisher" | "workspace";
|
|
12823
|
+
source?: string;
|
|
12824
|
+
firstSeenAt?: string;
|
|
12825
|
+
lastUpdatedAt?: string;
|
|
12270
12826
|
}>, "many">;
|
|
12271
12827
|
}, "strip", z.ZodTypeAny, {
|
|
12272
12828
|
items?: {
|
|
12273
12829
|
reason?: string;
|
|
12274
12830
|
id?: string;
|
|
12831
|
+
confidence?: number;
|
|
12275
12832
|
artifactId?: string;
|
|
12276
12833
|
artifactName?: string;
|
|
12277
12834
|
severity?: "low" | "medium" | "high";
|
|
12278
12835
|
publishedAt?: string;
|
|
12836
|
+
remediation?: string;
|
|
12837
|
+
scope?: "domain" | "ecosystem" | "artifact" | "publisher" | "workspace";
|
|
12838
|
+
source?: string;
|
|
12839
|
+
firstSeenAt?: string;
|
|
12840
|
+
lastUpdatedAt?: string;
|
|
12279
12841
|
}[];
|
|
12280
12842
|
generatedAt?: string;
|
|
12281
12843
|
}, {
|
|
12282
12844
|
items?: {
|
|
12283
12845
|
reason?: string;
|
|
12284
12846
|
id?: string;
|
|
12847
|
+
confidence?: number;
|
|
12285
12848
|
artifactId?: string;
|
|
12286
12849
|
artifactName?: string;
|
|
12287
12850
|
severity?: "low" | "medium" | "high";
|
|
12288
12851
|
publishedAt?: string;
|
|
12852
|
+
remediation?: string;
|
|
12853
|
+
scope?: "domain" | "ecosystem" | "artifact" | "publisher" | "workspace";
|
|
12854
|
+
source?: string;
|
|
12855
|
+
firstSeenAt?: string;
|
|
12856
|
+
lastUpdatedAt?: string;
|
|
12289
12857
|
}[];
|
|
12290
12858
|
generatedAt?: string;
|
|
12291
12859
|
}>;
|
|
@@ -12310,10 +12878,11 @@ declare const guardReceiptSchema: z.ZodObject<{
|
|
|
12310
12878
|
capabilities?: string[];
|
|
12311
12879
|
summary?: string;
|
|
12312
12880
|
recommendation?: "monitor" | "review" | "block";
|
|
12881
|
+
artifactType?: "skill" | "plugin";
|
|
12313
12882
|
artifactId?: string;
|
|
12314
12883
|
artifactName?: string;
|
|
12315
|
-
artifactType?: "skill" | "plugin";
|
|
12316
12884
|
artifactSlug?: string;
|
|
12885
|
+
publisher?: string;
|
|
12317
12886
|
receiptId?: string;
|
|
12318
12887
|
capturedAt?: string;
|
|
12319
12888
|
harness?: string;
|
|
@@ -12322,15 +12891,15 @@ declare const guardReceiptSchema: z.ZodObject<{
|
|
|
12322
12891
|
artifactHash?: string;
|
|
12323
12892
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12324
12893
|
changedSinceLastApproval?: boolean;
|
|
12325
|
-
publisher?: string;
|
|
12326
12894
|
}, {
|
|
12327
12895
|
capabilities?: string[];
|
|
12328
12896
|
summary?: string;
|
|
12329
12897
|
recommendation?: "monitor" | "review" | "block";
|
|
12898
|
+
artifactType?: "skill" | "plugin";
|
|
12330
12899
|
artifactId?: string;
|
|
12331
12900
|
artifactName?: string;
|
|
12332
|
-
artifactType?: "skill" | "plugin";
|
|
12333
12901
|
artifactSlug?: string;
|
|
12902
|
+
publisher?: string;
|
|
12334
12903
|
receiptId?: string;
|
|
12335
12904
|
capturedAt?: string;
|
|
12336
12905
|
harness?: string;
|
|
@@ -12339,7 +12908,6 @@ declare const guardReceiptSchema: z.ZodObject<{
|
|
|
12339
12908
|
artifactHash?: string;
|
|
12340
12909
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12341
12910
|
changedSinceLastApproval?: boolean;
|
|
12342
|
-
publisher?: string;
|
|
12343
12911
|
}>;
|
|
12344
12912
|
declare const guardHistoryArtifactSchema: z.ZodObject<{
|
|
12345
12913
|
artifactId: z.ZodString;
|
|
@@ -12354,26 +12922,26 @@ declare const guardHistoryArtifactSchema: z.ZodObject<{
|
|
|
12354
12922
|
latestDecision: z.ZodEnum<["allow", "warn", "block", "review", "require-reapproval", "sandbox-required"]>;
|
|
12355
12923
|
latestRecommendation: z.ZodEnum<["monitor", "review", "block"]>;
|
|
12356
12924
|
}, "strip", z.ZodTypeAny, {
|
|
12925
|
+
artifactType?: "skill" | "plugin";
|
|
12357
12926
|
artifactId?: string;
|
|
12358
12927
|
artifactName?: string;
|
|
12359
|
-
artifactType?: "skill" | "plugin";
|
|
12360
12928
|
artifactSlug?: string;
|
|
12361
12929
|
publisher?: string;
|
|
12930
|
+
firstSeenAt?: string;
|
|
12362
12931
|
harnesses?: string[];
|
|
12363
12932
|
eventCount?: number;
|
|
12364
|
-
firstSeenAt?: string;
|
|
12365
12933
|
lastSeenAt?: string;
|
|
12366
12934
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12367
12935
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
12368
12936
|
}, {
|
|
12937
|
+
artifactType?: "skill" | "plugin";
|
|
12369
12938
|
artifactId?: string;
|
|
12370
12939
|
artifactName?: string;
|
|
12371
|
-
artifactType?: "skill" | "plugin";
|
|
12372
12940
|
artifactSlug?: string;
|
|
12373
12941
|
publisher?: string;
|
|
12942
|
+
firstSeenAt?: string;
|
|
12374
12943
|
harnesses?: string[];
|
|
12375
12944
|
eventCount?: number;
|
|
12376
|
-
firstSeenAt?: string;
|
|
12377
12945
|
lastSeenAt?: string;
|
|
12378
12946
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12379
12947
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12393,40 +12961,40 @@ declare const guardReceiptHistoryResponseSchema: z.ZodObject<{
|
|
|
12393
12961
|
latestDecision: z.ZodEnum<["allow", "warn", "block", "review", "require-reapproval", "sandbox-required"]>;
|
|
12394
12962
|
latestRecommendation: z.ZodEnum<["monitor", "review", "block"]>;
|
|
12395
12963
|
}, "strip", z.ZodTypeAny, {
|
|
12964
|
+
artifactType?: "skill" | "plugin";
|
|
12396
12965
|
artifactId?: string;
|
|
12397
12966
|
artifactName?: string;
|
|
12398
|
-
artifactType?: "skill" | "plugin";
|
|
12399
12967
|
artifactSlug?: string;
|
|
12400
12968
|
publisher?: string;
|
|
12969
|
+
firstSeenAt?: string;
|
|
12401
12970
|
harnesses?: string[];
|
|
12402
12971
|
eventCount?: number;
|
|
12403
|
-
firstSeenAt?: string;
|
|
12404
12972
|
lastSeenAt?: string;
|
|
12405
12973
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12406
12974
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
12407
12975
|
}, {
|
|
12976
|
+
artifactType?: "skill" | "plugin";
|
|
12408
12977
|
artifactId?: string;
|
|
12409
12978
|
artifactName?: string;
|
|
12410
|
-
artifactType?: "skill" | "plugin";
|
|
12411
12979
|
artifactSlug?: string;
|
|
12412
12980
|
publisher?: string;
|
|
12981
|
+
firstSeenAt?: string;
|
|
12413
12982
|
harnesses?: string[];
|
|
12414
12983
|
eventCount?: number;
|
|
12415
|
-
firstSeenAt?: string;
|
|
12416
12984
|
lastSeenAt?: string;
|
|
12417
12985
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12418
12986
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
12419
12987
|
}>, "many">;
|
|
12420
12988
|
}, "strip", z.ZodTypeAny, {
|
|
12421
12989
|
artifacts?: {
|
|
12990
|
+
artifactType?: "skill" | "plugin";
|
|
12422
12991
|
artifactId?: string;
|
|
12423
12992
|
artifactName?: string;
|
|
12424
|
-
artifactType?: "skill" | "plugin";
|
|
12425
12993
|
artifactSlug?: string;
|
|
12426
12994
|
publisher?: string;
|
|
12995
|
+
firstSeenAt?: string;
|
|
12427
12996
|
harnesses?: string[];
|
|
12428
12997
|
eventCount?: number;
|
|
12429
|
-
firstSeenAt?: string;
|
|
12430
12998
|
lastSeenAt?: string;
|
|
12431
12999
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12432
13000
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12434,14 +13002,14 @@ declare const guardReceiptHistoryResponseSchema: z.ZodObject<{
|
|
|
12434
13002
|
generatedAt?: string;
|
|
12435
13003
|
}, {
|
|
12436
13004
|
artifacts?: {
|
|
13005
|
+
artifactType?: "skill" | "plugin";
|
|
12437
13006
|
artifactId?: string;
|
|
12438
13007
|
artifactName?: string;
|
|
12439
|
-
artifactType?: "skill" | "plugin";
|
|
12440
13008
|
artifactSlug?: string;
|
|
12441
13009
|
publisher?: string;
|
|
13010
|
+
firstSeenAt?: string;
|
|
12442
13011
|
harnesses?: string[];
|
|
12443
13012
|
eventCount?: number;
|
|
12444
|
-
firstSeenAt?: string;
|
|
12445
13013
|
lastSeenAt?: string;
|
|
12446
13014
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12447
13015
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12464,14 +13032,14 @@ declare const guardInventoryArtifactSchema: z.ZodObject<{
|
|
|
12464
13032
|
latestHash: z.ZodString;
|
|
12465
13033
|
latestSummary: z.ZodString;
|
|
12466
13034
|
}, "strip", z.ZodTypeAny, {
|
|
13035
|
+
artifactType?: "skill" | "plugin";
|
|
12467
13036
|
artifactId?: string;
|
|
12468
13037
|
artifactName?: string;
|
|
12469
|
-
artifactType?: "skill" | "plugin";
|
|
12470
13038
|
artifactSlug?: string;
|
|
12471
13039
|
publisher?: string;
|
|
13040
|
+
firstSeenAt?: string;
|
|
12472
13041
|
harnesses?: string[];
|
|
12473
13042
|
eventCount?: number;
|
|
12474
|
-
firstSeenAt?: string;
|
|
12475
13043
|
lastSeenAt?: string;
|
|
12476
13044
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12477
13045
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12479,14 +13047,14 @@ declare const guardInventoryArtifactSchema: z.ZodObject<{
|
|
|
12479
13047
|
latestHash?: string;
|
|
12480
13048
|
latestSummary?: string;
|
|
12481
13049
|
}, {
|
|
13050
|
+
artifactType?: "skill" | "plugin";
|
|
12482
13051
|
artifactId?: string;
|
|
12483
13052
|
artifactName?: string;
|
|
12484
|
-
artifactType?: "skill" | "plugin";
|
|
12485
13053
|
artifactSlug?: string;
|
|
12486
13054
|
publisher?: string;
|
|
13055
|
+
firstSeenAt?: string;
|
|
12487
13056
|
harnesses?: string[];
|
|
12488
13057
|
eventCount?: number;
|
|
12489
|
-
firstSeenAt?: string;
|
|
12490
13058
|
lastSeenAt?: string;
|
|
12491
13059
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12492
13060
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12502,16 +13070,16 @@ declare const guardInventoryDiffEntrySchema: z.ZodObject<{
|
|
|
12502
13070
|
previousHash: z.ZodNullable<z.ZodString>;
|
|
12503
13071
|
currentHash: z.ZodNullable<z.ZodString>;
|
|
12504
13072
|
}, "strip", z.ZodTypeAny, {
|
|
13073
|
+
artifactType?: "skill" | "plugin";
|
|
12505
13074
|
artifactId?: string;
|
|
12506
13075
|
artifactName?: string;
|
|
12507
|
-
artifactType?: "skill" | "plugin";
|
|
12508
13076
|
changeType?: "new" | "changed" | "removed";
|
|
12509
13077
|
previousHash?: string;
|
|
12510
13078
|
currentHash?: string;
|
|
12511
13079
|
}, {
|
|
13080
|
+
artifactType?: "skill" | "plugin";
|
|
12512
13081
|
artifactId?: string;
|
|
12513
13082
|
artifactName?: string;
|
|
12514
|
-
artifactType?: "skill" | "plugin";
|
|
12515
13083
|
changeType?: "new" | "changed" | "removed";
|
|
12516
13084
|
previousHash?: string;
|
|
12517
13085
|
currentHash?: string;
|
|
@@ -12526,25 +13094,25 @@ declare const guardInventoryDiffResponseSchema: z.ZodObject<{
|
|
|
12526
13094
|
previousHash: z.ZodNullable<z.ZodString>;
|
|
12527
13095
|
currentHash: z.ZodNullable<z.ZodString>;
|
|
12528
13096
|
}, "strip", z.ZodTypeAny, {
|
|
13097
|
+
artifactType?: "skill" | "plugin";
|
|
12529
13098
|
artifactId?: string;
|
|
12530
13099
|
artifactName?: string;
|
|
12531
|
-
artifactType?: "skill" | "plugin";
|
|
12532
13100
|
changeType?: "new" | "changed" | "removed";
|
|
12533
13101
|
previousHash?: string;
|
|
12534
13102
|
currentHash?: string;
|
|
12535
13103
|
}, {
|
|
13104
|
+
artifactType?: "skill" | "plugin";
|
|
12536
13105
|
artifactId?: string;
|
|
12537
13106
|
artifactName?: string;
|
|
12538
|
-
artifactType?: "skill" | "plugin";
|
|
12539
13107
|
changeType?: "new" | "changed" | "removed";
|
|
12540
13108
|
previousHash?: string;
|
|
12541
13109
|
currentHash?: string;
|
|
12542
13110
|
}>, "many">;
|
|
12543
13111
|
}, "strip", z.ZodTypeAny, {
|
|
12544
13112
|
items?: {
|
|
13113
|
+
artifactType?: "skill" | "plugin";
|
|
12545
13114
|
artifactId?: string;
|
|
12546
13115
|
artifactName?: string;
|
|
12547
|
-
artifactType?: "skill" | "plugin";
|
|
12548
13116
|
changeType?: "new" | "changed" | "removed";
|
|
12549
13117
|
previousHash?: string;
|
|
12550
13118
|
currentHash?: string;
|
|
@@ -12552,9 +13120,9 @@ declare const guardInventoryDiffResponseSchema: z.ZodObject<{
|
|
|
12552
13120
|
generatedAt?: string;
|
|
12553
13121
|
}, {
|
|
12554
13122
|
items?: {
|
|
13123
|
+
artifactType?: "skill" | "plugin";
|
|
12555
13124
|
artifactId?: string;
|
|
12556
13125
|
artifactName?: string;
|
|
12557
|
-
artifactType?: "skill" | "plugin";
|
|
12558
13126
|
changeType?: "new" | "changed" | "removed";
|
|
12559
13127
|
previousHash?: string;
|
|
12560
13128
|
currentHash?: string;
|
|
@@ -12575,25 +13143,25 @@ declare const guardReceiptSyncResponseSchema: z.ZodObject<{
|
|
|
12575
13143
|
previousHash: z.ZodNullable<z.ZodString>;
|
|
12576
13144
|
currentHash: z.ZodNullable<z.ZodString>;
|
|
12577
13145
|
}, "strip", z.ZodTypeAny, {
|
|
13146
|
+
artifactType?: "skill" | "plugin";
|
|
12578
13147
|
artifactId?: string;
|
|
12579
13148
|
artifactName?: string;
|
|
12580
|
-
artifactType?: "skill" | "plugin";
|
|
12581
13149
|
changeType?: "new" | "changed" | "removed";
|
|
12582
13150
|
previousHash?: string;
|
|
12583
13151
|
currentHash?: string;
|
|
12584
13152
|
}, {
|
|
13153
|
+
artifactType?: "skill" | "plugin";
|
|
12585
13154
|
artifactId?: string;
|
|
12586
13155
|
artifactName?: string;
|
|
12587
|
-
artifactType?: "skill" | "plugin";
|
|
12588
13156
|
changeType?: "new" | "changed" | "removed";
|
|
12589
13157
|
previousHash?: string;
|
|
12590
13158
|
currentHash?: string;
|
|
12591
13159
|
}>, "many">;
|
|
12592
13160
|
}, "strip", z.ZodTypeAny, {
|
|
12593
13161
|
items?: {
|
|
13162
|
+
artifactType?: "skill" | "plugin";
|
|
12594
13163
|
artifactId?: string;
|
|
12595
13164
|
artifactName?: string;
|
|
12596
|
-
artifactType?: "skill" | "plugin";
|
|
12597
13165
|
changeType?: "new" | "changed" | "removed";
|
|
12598
13166
|
previousHash?: string;
|
|
12599
13167
|
currentHash?: string;
|
|
@@ -12601,45 +13169,360 @@ declare const guardReceiptSyncResponseSchema: z.ZodObject<{
|
|
|
12601
13169
|
generatedAt?: string;
|
|
12602
13170
|
}, {
|
|
12603
13171
|
items?: {
|
|
13172
|
+
artifactType?: "skill" | "plugin";
|
|
12604
13173
|
artifactId?: string;
|
|
12605
13174
|
artifactName?: string;
|
|
12606
|
-
artifactType?: "skill" | "plugin";
|
|
12607
13175
|
changeType?: "new" | "changed" | "removed";
|
|
12608
13176
|
previousHash?: string;
|
|
12609
13177
|
currentHash?: string;
|
|
12610
13178
|
}[];
|
|
12611
13179
|
generatedAt?: string;
|
|
12612
13180
|
}>>;
|
|
13181
|
+
advisories: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
13182
|
+
id: z.ZodString;
|
|
13183
|
+
artifactId: z.ZodString;
|
|
13184
|
+
artifactName: z.ZodString;
|
|
13185
|
+
reason: z.ZodString;
|
|
13186
|
+
severity: z.ZodEnum<["low", "medium", "high"]>;
|
|
13187
|
+
publishedAt: z.ZodString;
|
|
13188
|
+
confidence: z.ZodOptional<z.ZodNumber>;
|
|
13189
|
+
remediation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
13190
|
+
scope: z.ZodOptional<z.ZodEnum<["artifact", "publisher", "domain", "workspace", "ecosystem"]>>;
|
|
13191
|
+
source: z.ZodOptional<z.ZodString>;
|
|
13192
|
+
firstSeenAt: z.ZodOptional<z.ZodString>;
|
|
13193
|
+
lastUpdatedAt: z.ZodOptional<z.ZodString>;
|
|
13194
|
+
}, "strip", z.ZodTypeAny, {
|
|
13195
|
+
reason?: string;
|
|
13196
|
+
id?: string;
|
|
13197
|
+
confidence?: number;
|
|
13198
|
+
artifactId?: string;
|
|
13199
|
+
artifactName?: string;
|
|
13200
|
+
severity?: "low" | "medium" | "high";
|
|
13201
|
+
publishedAt?: string;
|
|
13202
|
+
remediation?: string;
|
|
13203
|
+
scope?: "domain" | "ecosystem" | "artifact" | "publisher" | "workspace";
|
|
13204
|
+
source?: string;
|
|
13205
|
+
firstSeenAt?: string;
|
|
13206
|
+
lastUpdatedAt?: string;
|
|
13207
|
+
}, {
|
|
13208
|
+
reason?: string;
|
|
13209
|
+
id?: string;
|
|
13210
|
+
confidence?: number;
|
|
13211
|
+
artifactId?: string;
|
|
13212
|
+
artifactName?: string;
|
|
13213
|
+
severity?: "low" | "medium" | "high";
|
|
13214
|
+
publishedAt?: string;
|
|
13215
|
+
remediation?: string;
|
|
13216
|
+
scope?: "domain" | "ecosystem" | "artifact" | "publisher" | "workspace";
|
|
13217
|
+
source?: string;
|
|
13218
|
+
firstSeenAt?: string;
|
|
13219
|
+
lastUpdatedAt?: string;
|
|
13220
|
+
}>, "many">>;
|
|
13221
|
+
policy: z.ZodOptional<z.ZodObject<{
|
|
13222
|
+
mode: z.ZodEnum<["observe", "prompt", "enforce"]>;
|
|
13223
|
+
defaultAction: z.ZodEnum<["allow", "warn", "block"]>;
|
|
13224
|
+
unknownPublisherAction: z.ZodEnum<["review", "block", "allow"]>;
|
|
13225
|
+
changedHashAction: z.ZodEnum<["allow", "warn", "require-reapproval", "block"]>;
|
|
13226
|
+
newNetworkDomainAction: z.ZodEnum<["allow", "warn", "block"]>;
|
|
13227
|
+
subprocessAction: z.ZodEnum<["allow", "warn", "block"]>;
|
|
13228
|
+
telemetryEnabled: z.ZodBoolean;
|
|
13229
|
+
syncEnabled: z.ZodBoolean;
|
|
13230
|
+
updatedAt: z.ZodString;
|
|
13231
|
+
}, "strip", z.ZodTypeAny, {
|
|
13232
|
+
mode?: "observe" | "prompt" | "enforce";
|
|
13233
|
+
updatedAt?: string;
|
|
13234
|
+
syncEnabled?: boolean;
|
|
13235
|
+
defaultAction?: "warn" | "block" | "allow";
|
|
13236
|
+
unknownPublisherAction?: "review" | "block" | "allow";
|
|
13237
|
+
changedHashAction?: "warn" | "block" | "allow" | "require-reapproval";
|
|
13238
|
+
newNetworkDomainAction?: "warn" | "block" | "allow";
|
|
13239
|
+
subprocessAction?: "warn" | "block" | "allow";
|
|
13240
|
+
telemetryEnabled?: boolean;
|
|
13241
|
+
}, {
|
|
13242
|
+
mode?: "observe" | "prompt" | "enforce";
|
|
13243
|
+
updatedAt?: string;
|
|
13244
|
+
syncEnabled?: boolean;
|
|
13245
|
+
defaultAction?: "warn" | "block" | "allow";
|
|
13246
|
+
unknownPublisherAction?: "review" | "block" | "allow";
|
|
13247
|
+
changedHashAction?: "warn" | "block" | "allow" | "require-reapproval";
|
|
13248
|
+
newNetworkDomainAction?: "warn" | "block" | "allow";
|
|
13249
|
+
subprocessAction?: "warn" | "block" | "allow";
|
|
13250
|
+
telemetryEnabled?: boolean;
|
|
13251
|
+
}>>;
|
|
13252
|
+
alertPreferences: z.ZodOptional<z.ZodLazy<z.ZodObject<{
|
|
13253
|
+
emailEnabled: z.ZodBoolean;
|
|
13254
|
+
digestMode: z.ZodEnum<["immediate", "daily", "weekly"]>;
|
|
13255
|
+
watchlistEnabled: z.ZodBoolean;
|
|
13256
|
+
advisoriesEnabled: z.ZodBoolean;
|
|
13257
|
+
repeatedWarningsEnabled: z.ZodBoolean;
|
|
13258
|
+
teamAlertsEnabled: z.ZodBoolean;
|
|
13259
|
+
updatedAt: z.ZodString;
|
|
13260
|
+
}, "strip", z.ZodTypeAny, {
|
|
13261
|
+
updatedAt?: string;
|
|
13262
|
+
emailEnabled?: boolean;
|
|
13263
|
+
digestMode?: "immediate" | "daily" | "weekly";
|
|
13264
|
+
watchlistEnabled?: boolean;
|
|
13265
|
+
advisoriesEnabled?: boolean;
|
|
13266
|
+
repeatedWarningsEnabled?: boolean;
|
|
13267
|
+
teamAlertsEnabled?: boolean;
|
|
13268
|
+
}, {
|
|
13269
|
+
updatedAt?: string;
|
|
13270
|
+
emailEnabled?: boolean;
|
|
13271
|
+
digestMode?: "immediate" | "daily" | "weekly";
|
|
13272
|
+
watchlistEnabled?: boolean;
|
|
13273
|
+
advisoriesEnabled?: boolean;
|
|
13274
|
+
repeatedWarningsEnabled?: boolean;
|
|
13275
|
+
teamAlertsEnabled?: boolean;
|
|
13276
|
+
}>>>;
|
|
13277
|
+
exceptions: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
|
|
13278
|
+
exceptionId: z.ZodString;
|
|
13279
|
+
scope: z.ZodEnum<["artifact", "publisher", "harness", "global"]>;
|
|
13280
|
+
harness: z.ZodNullable<z.ZodString>;
|
|
13281
|
+
artifactId: z.ZodNullable<z.ZodString>;
|
|
13282
|
+
publisher: z.ZodNullable<z.ZodString>;
|
|
13283
|
+
reason: z.ZodString;
|
|
13284
|
+
owner: z.ZodString;
|
|
13285
|
+
source: z.ZodEnum<["manual", "team-policy"]>;
|
|
13286
|
+
expiresAt: z.ZodString;
|
|
13287
|
+
createdAt: z.ZodString;
|
|
13288
|
+
updatedAt: z.ZodString;
|
|
13289
|
+
}, "strip", z.ZodTypeAny, {
|
|
13290
|
+
reason?: string;
|
|
13291
|
+
owner?: string;
|
|
13292
|
+
createdAt?: string;
|
|
13293
|
+
updatedAt?: string;
|
|
13294
|
+
expiresAt?: string;
|
|
13295
|
+
artifactId?: string;
|
|
13296
|
+
publisher?: string;
|
|
13297
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13298
|
+
source?: "manual" | "team-policy";
|
|
13299
|
+
harness?: string;
|
|
13300
|
+
exceptionId?: string;
|
|
13301
|
+
}, {
|
|
13302
|
+
reason?: string;
|
|
13303
|
+
owner?: string;
|
|
13304
|
+
createdAt?: string;
|
|
13305
|
+
updatedAt?: string;
|
|
13306
|
+
expiresAt?: string;
|
|
13307
|
+
artifactId?: string;
|
|
13308
|
+
publisher?: string;
|
|
13309
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13310
|
+
source?: "manual" | "team-policy";
|
|
13311
|
+
harness?: string;
|
|
13312
|
+
exceptionId?: string;
|
|
13313
|
+
}>>, "many">>;
|
|
13314
|
+
teamPolicyPack: z.ZodOptional<z.ZodLazy<z.ZodObject<{
|
|
13315
|
+
name: z.ZodString;
|
|
13316
|
+
sharedHarnessDefaults: z.ZodRecord<z.ZodString, z.ZodEnum<["observe", "prompt", "enforce"]>>;
|
|
13317
|
+
allowedPublishers: z.ZodArray<z.ZodString, "many">;
|
|
13318
|
+
blockedPublishers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
13319
|
+
blockedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
13320
|
+
blockedArtifacts: z.ZodArray<z.ZodString, "many">;
|
|
13321
|
+
alertChannel: z.ZodEnum<["email", "slack", "teams", "webhook"]>;
|
|
13322
|
+
updatedAt: z.ZodString;
|
|
13323
|
+
auditTrail: z.ZodArray<z.ZodObject<{
|
|
13324
|
+
changedAt: z.ZodString;
|
|
13325
|
+
actor: z.ZodString;
|
|
13326
|
+
change: z.ZodEnum<["created", "updated"]>;
|
|
13327
|
+
summary: z.ZodString;
|
|
13328
|
+
}, "strip", z.ZodTypeAny, {
|
|
13329
|
+
summary?: string;
|
|
13330
|
+
changedAt?: string;
|
|
13331
|
+
actor?: string;
|
|
13332
|
+
change?: "created" | "updated";
|
|
13333
|
+
}, {
|
|
13334
|
+
summary?: string;
|
|
13335
|
+
changedAt?: string;
|
|
13336
|
+
actor?: string;
|
|
13337
|
+
change?: "created" | "updated";
|
|
13338
|
+
}>, "many">;
|
|
13339
|
+
}, "strip", z.ZodTypeAny, {
|
|
13340
|
+
name?: string;
|
|
13341
|
+
updatedAt?: string;
|
|
13342
|
+
sharedHarnessDefaults?: Record<string, "observe" | "prompt" | "enforce">;
|
|
13343
|
+
allowedPublishers?: string[];
|
|
13344
|
+
blockedPublishers?: string[];
|
|
13345
|
+
blockedDomains?: string[];
|
|
13346
|
+
blockedArtifacts?: string[];
|
|
13347
|
+
alertChannel?: "email" | "slack" | "teams" | "webhook";
|
|
13348
|
+
auditTrail?: {
|
|
13349
|
+
summary?: string;
|
|
13350
|
+
changedAt?: string;
|
|
13351
|
+
actor?: string;
|
|
13352
|
+
change?: "created" | "updated";
|
|
13353
|
+
}[];
|
|
13354
|
+
}, {
|
|
13355
|
+
name?: string;
|
|
13356
|
+
updatedAt?: string;
|
|
13357
|
+
sharedHarnessDefaults?: Record<string, "observe" | "prompt" | "enforce">;
|
|
13358
|
+
allowedPublishers?: string[];
|
|
13359
|
+
blockedPublishers?: string[];
|
|
13360
|
+
blockedDomains?: string[];
|
|
13361
|
+
blockedArtifacts?: string[];
|
|
13362
|
+
alertChannel?: "email" | "slack" | "teams" | "webhook";
|
|
13363
|
+
auditTrail?: {
|
|
13364
|
+
summary?: string;
|
|
13365
|
+
changedAt?: string;
|
|
13366
|
+
actor?: string;
|
|
13367
|
+
change?: "created" | "updated";
|
|
13368
|
+
}[];
|
|
13369
|
+
}>>>;
|
|
12613
13370
|
}, "strip", z.ZodTypeAny, {
|
|
12614
13371
|
syncedAt?: string;
|
|
12615
13372
|
receiptsStored?: number;
|
|
12616
13373
|
inventoryStored?: number;
|
|
12617
13374
|
inventoryDiff?: {
|
|
12618
13375
|
items?: {
|
|
13376
|
+
artifactType?: "skill" | "plugin";
|
|
12619
13377
|
artifactId?: string;
|
|
12620
13378
|
artifactName?: string;
|
|
12621
|
-
artifactType?: "skill" | "plugin";
|
|
12622
13379
|
changeType?: "new" | "changed" | "removed";
|
|
12623
13380
|
previousHash?: string;
|
|
12624
13381
|
currentHash?: string;
|
|
12625
13382
|
}[];
|
|
12626
13383
|
generatedAt?: string;
|
|
12627
13384
|
};
|
|
13385
|
+
advisories?: {
|
|
13386
|
+
reason?: string;
|
|
13387
|
+
id?: string;
|
|
13388
|
+
confidence?: number;
|
|
13389
|
+
artifactId?: string;
|
|
13390
|
+
artifactName?: string;
|
|
13391
|
+
severity?: "low" | "medium" | "high";
|
|
13392
|
+
publishedAt?: string;
|
|
13393
|
+
remediation?: string;
|
|
13394
|
+
scope?: "domain" | "ecosystem" | "artifact" | "publisher" | "workspace";
|
|
13395
|
+
source?: string;
|
|
13396
|
+
firstSeenAt?: string;
|
|
13397
|
+
lastUpdatedAt?: string;
|
|
13398
|
+
}[];
|
|
13399
|
+
policy?: {
|
|
13400
|
+
mode?: "observe" | "prompt" | "enforce";
|
|
13401
|
+
updatedAt?: string;
|
|
13402
|
+
syncEnabled?: boolean;
|
|
13403
|
+
defaultAction?: "warn" | "block" | "allow";
|
|
13404
|
+
unknownPublisherAction?: "review" | "block" | "allow";
|
|
13405
|
+
changedHashAction?: "warn" | "block" | "allow" | "require-reapproval";
|
|
13406
|
+
newNetworkDomainAction?: "warn" | "block" | "allow";
|
|
13407
|
+
subprocessAction?: "warn" | "block" | "allow";
|
|
13408
|
+
telemetryEnabled?: boolean;
|
|
13409
|
+
};
|
|
13410
|
+
alertPreferences?: {
|
|
13411
|
+
updatedAt?: string;
|
|
13412
|
+
emailEnabled?: boolean;
|
|
13413
|
+
digestMode?: "immediate" | "daily" | "weekly";
|
|
13414
|
+
watchlistEnabled?: boolean;
|
|
13415
|
+
advisoriesEnabled?: boolean;
|
|
13416
|
+
repeatedWarningsEnabled?: boolean;
|
|
13417
|
+
teamAlertsEnabled?: boolean;
|
|
13418
|
+
};
|
|
13419
|
+
exceptions?: {
|
|
13420
|
+
reason?: string;
|
|
13421
|
+
owner?: string;
|
|
13422
|
+
createdAt?: string;
|
|
13423
|
+
updatedAt?: string;
|
|
13424
|
+
expiresAt?: string;
|
|
13425
|
+
artifactId?: string;
|
|
13426
|
+
publisher?: string;
|
|
13427
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13428
|
+
source?: "manual" | "team-policy";
|
|
13429
|
+
harness?: string;
|
|
13430
|
+
exceptionId?: string;
|
|
13431
|
+
}[];
|
|
13432
|
+
teamPolicyPack?: {
|
|
13433
|
+
name?: string;
|
|
13434
|
+
updatedAt?: string;
|
|
13435
|
+
sharedHarnessDefaults?: Record<string, "observe" | "prompt" | "enforce">;
|
|
13436
|
+
allowedPublishers?: string[];
|
|
13437
|
+
blockedPublishers?: string[];
|
|
13438
|
+
blockedDomains?: string[];
|
|
13439
|
+
blockedArtifacts?: string[];
|
|
13440
|
+
alertChannel?: "email" | "slack" | "teams" | "webhook";
|
|
13441
|
+
auditTrail?: {
|
|
13442
|
+
summary?: string;
|
|
13443
|
+
changedAt?: string;
|
|
13444
|
+
actor?: string;
|
|
13445
|
+
change?: "created" | "updated";
|
|
13446
|
+
}[];
|
|
13447
|
+
};
|
|
12628
13448
|
}, {
|
|
12629
13449
|
syncedAt?: string;
|
|
12630
13450
|
receiptsStored?: number;
|
|
12631
13451
|
inventoryStored?: number;
|
|
12632
13452
|
inventoryDiff?: {
|
|
12633
13453
|
items?: {
|
|
13454
|
+
artifactType?: "skill" | "plugin";
|
|
12634
13455
|
artifactId?: string;
|
|
12635
13456
|
artifactName?: string;
|
|
12636
|
-
artifactType?: "skill" | "plugin";
|
|
12637
13457
|
changeType?: "new" | "changed" | "removed";
|
|
12638
13458
|
previousHash?: string;
|
|
12639
13459
|
currentHash?: string;
|
|
12640
13460
|
}[];
|
|
12641
13461
|
generatedAt?: string;
|
|
12642
13462
|
};
|
|
13463
|
+
advisories?: {
|
|
13464
|
+
reason?: string;
|
|
13465
|
+
id?: string;
|
|
13466
|
+
confidence?: number;
|
|
13467
|
+
artifactId?: string;
|
|
13468
|
+
artifactName?: string;
|
|
13469
|
+
severity?: "low" | "medium" | "high";
|
|
13470
|
+
publishedAt?: string;
|
|
13471
|
+
remediation?: string;
|
|
13472
|
+
scope?: "domain" | "ecosystem" | "artifact" | "publisher" | "workspace";
|
|
13473
|
+
source?: string;
|
|
13474
|
+
firstSeenAt?: string;
|
|
13475
|
+
lastUpdatedAt?: string;
|
|
13476
|
+
}[];
|
|
13477
|
+
policy?: {
|
|
13478
|
+
mode?: "observe" | "prompt" | "enforce";
|
|
13479
|
+
updatedAt?: string;
|
|
13480
|
+
syncEnabled?: boolean;
|
|
13481
|
+
defaultAction?: "warn" | "block" | "allow";
|
|
13482
|
+
unknownPublisherAction?: "review" | "block" | "allow";
|
|
13483
|
+
changedHashAction?: "warn" | "block" | "allow" | "require-reapproval";
|
|
13484
|
+
newNetworkDomainAction?: "warn" | "block" | "allow";
|
|
13485
|
+
subprocessAction?: "warn" | "block" | "allow";
|
|
13486
|
+
telemetryEnabled?: boolean;
|
|
13487
|
+
};
|
|
13488
|
+
alertPreferences?: {
|
|
13489
|
+
updatedAt?: string;
|
|
13490
|
+
emailEnabled?: boolean;
|
|
13491
|
+
digestMode?: "immediate" | "daily" | "weekly";
|
|
13492
|
+
watchlistEnabled?: boolean;
|
|
13493
|
+
advisoriesEnabled?: boolean;
|
|
13494
|
+
repeatedWarningsEnabled?: boolean;
|
|
13495
|
+
teamAlertsEnabled?: boolean;
|
|
13496
|
+
};
|
|
13497
|
+
exceptions?: {
|
|
13498
|
+
reason?: string;
|
|
13499
|
+
owner?: string;
|
|
13500
|
+
createdAt?: string;
|
|
13501
|
+
updatedAt?: string;
|
|
13502
|
+
expiresAt?: string;
|
|
13503
|
+
artifactId?: string;
|
|
13504
|
+
publisher?: string;
|
|
13505
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13506
|
+
source?: "manual" | "team-policy";
|
|
13507
|
+
harness?: string;
|
|
13508
|
+
exceptionId?: string;
|
|
13509
|
+
}[];
|
|
13510
|
+
teamPolicyPack?: {
|
|
13511
|
+
name?: string;
|
|
13512
|
+
updatedAt?: string;
|
|
13513
|
+
sharedHarnessDefaults?: Record<string, "observe" | "prompt" | "enforce">;
|
|
13514
|
+
allowedPublishers?: string[];
|
|
13515
|
+
blockedPublishers?: string[];
|
|
13516
|
+
blockedDomains?: string[];
|
|
13517
|
+
blockedArtifacts?: string[];
|
|
13518
|
+
alertChannel?: "email" | "slack" | "teams" | "webhook";
|
|
13519
|
+
auditTrail?: {
|
|
13520
|
+
summary?: string;
|
|
13521
|
+
changedAt?: string;
|
|
13522
|
+
actor?: string;
|
|
13523
|
+
change?: "created" | "updated";
|
|
13524
|
+
}[];
|
|
13525
|
+
};
|
|
12643
13526
|
}>;
|
|
12644
13527
|
declare const guardInventoryResponseSchema: z.ZodObject<{
|
|
12645
13528
|
generatedAt: z.ZodString;
|
|
@@ -12659,14 +13542,14 @@ declare const guardInventoryResponseSchema: z.ZodObject<{
|
|
|
12659
13542
|
latestHash: z.ZodString;
|
|
12660
13543
|
latestSummary: z.ZodString;
|
|
12661
13544
|
}, "strip", z.ZodTypeAny, {
|
|
13545
|
+
artifactType?: "skill" | "plugin";
|
|
12662
13546
|
artifactId?: string;
|
|
12663
13547
|
artifactName?: string;
|
|
12664
|
-
artifactType?: "skill" | "plugin";
|
|
12665
13548
|
artifactSlug?: string;
|
|
12666
13549
|
publisher?: string;
|
|
13550
|
+
firstSeenAt?: string;
|
|
12667
13551
|
harnesses?: string[];
|
|
12668
13552
|
eventCount?: number;
|
|
12669
|
-
firstSeenAt?: string;
|
|
12670
13553
|
lastSeenAt?: string;
|
|
12671
13554
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12672
13555
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12674,14 +13557,14 @@ declare const guardInventoryResponseSchema: z.ZodObject<{
|
|
|
12674
13557
|
latestHash?: string;
|
|
12675
13558
|
latestSummary?: string;
|
|
12676
13559
|
}, {
|
|
13560
|
+
artifactType?: "skill" | "plugin";
|
|
12677
13561
|
artifactId?: string;
|
|
12678
13562
|
artifactName?: string;
|
|
12679
|
-
artifactType?: "skill" | "plugin";
|
|
12680
13563
|
artifactSlug?: string;
|
|
12681
13564
|
publisher?: string;
|
|
13565
|
+
firstSeenAt?: string;
|
|
12682
13566
|
harnesses?: string[];
|
|
12683
13567
|
eventCount?: number;
|
|
12684
|
-
firstSeenAt?: string;
|
|
12685
13568
|
lastSeenAt?: string;
|
|
12686
13569
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12687
13570
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12691,14 +13574,14 @@ declare const guardInventoryResponseSchema: z.ZodObject<{
|
|
|
12691
13574
|
}>, "many">;
|
|
12692
13575
|
}, "strip", z.ZodTypeAny, {
|
|
12693
13576
|
items?: {
|
|
13577
|
+
artifactType?: "skill" | "plugin";
|
|
12694
13578
|
artifactId?: string;
|
|
12695
13579
|
artifactName?: string;
|
|
12696
|
-
artifactType?: "skill" | "plugin";
|
|
12697
13580
|
artifactSlug?: string;
|
|
12698
13581
|
publisher?: string;
|
|
13582
|
+
firstSeenAt?: string;
|
|
12699
13583
|
harnesses?: string[];
|
|
12700
13584
|
eventCount?: number;
|
|
12701
|
-
firstSeenAt?: string;
|
|
12702
13585
|
lastSeenAt?: string;
|
|
12703
13586
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12704
13587
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12709,14 +13592,14 @@ declare const guardInventoryResponseSchema: z.ZodObject<{
|
|
|
12709
13592
|
generatedAt?: string;
|
|
12710
13593
|
}, {
|
|
12711
13594
|
items?: {
|
|
13595
|
+
artifactType?: "skill" | "plugin";
|
|
12712
13596
|
artifactId?: string;
|
|
12713
13597
|
artifactName?: string;
|
|
12714
|
-
artifactType?: "skill" | "plugin";
|
|
12715
13598
|
artifactSlug?: string;
|
|
12716
13599
|
publisher?: string;
|
|
13600
|
+
firstSeenAt?: string;
|
|
12717
13601
|
harnesses?: string[];
|
|
12718
13602
|
eventCount?: number;
|
|
12719
|
-
firstSeenAt?: string;
|
|
12720
13603
|
lastSeenAt?: string;
|
|
12721
13604
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12722
13605
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12733,16 +13616,16 @@ declare const guardAbomSummarySchema: z.ZodObject<{
|
|
|
12733
13616
|
blockedArtifacts: z.ZodNumber;
|
|
12734
13617
|
reviewArtifacts: z.ZodNumber;
|
|
12735
13618
|
}, "strip", z.ZodTypeAny, {
|
|
13619
|
+
blockedArtifacts?: number;
|
|
12736
13620
|
totalArtifacts?: number;
|
|
12737
13621
|
totalDevices?: number;
|
|
12738
13622
|
totalHarnesses?: number;
|
|
12739
|
-
blockedArtifacts?: number;
|
|
12740
13623
|
reviewArtifacts?: number;
|
|
12741
13624
|
}, {
|
|
13625
|
+
blockedArtifacts?: number;
|
|
12742
13626
|
totalArtifacts?: number;
|
|
12743
13627
|
totalDevices?: number;
|
|
12744
13628
|
totalHarnesses?: number;
|
|
12745
|
-
blockedArtifacts?: number;
|
|
12746
13629
|
reviewArtifacts?: number;
|
|
12747
13630
|
}>;
|
|
12748
13631
|
declare const guardAbomResponseSchema: z.ZodObject<{
|
|
@@ -12754,16 +13637,16 @@ declare const guardAbomResponseSchema: z.ZodObject<{
|
|
|
12754
13637
|
blockedArtifacts: z.ZodNumber;
|
|
12755
13638
|
reviewArtifacts: z.ZodNumber;
|
|
12756
13639
|
}, "strip", z.ZodTypeAny, {
|
|
13640
|
+
blockedArtifacts?: number;
|
|
12757
13641
|
totalArtifacts?: number;
|
|
12758
13642
|
totalDevices?: number;
|
|
12759
13643
|
totalHarnesses?: number;
|
|
12760
|
-
blockedArtifacts?: number;
|
|
12761
13644
|
reviewArtifacts?: number;
|
|
12762
13645
|
}, {
|
|
13646
|
+
blockedArtifacts?: number;
|
|
12763
13647
|
totalArtifacts?: number;
|
|
12764
13648
|
totalDevices?: number;
|
|
12765
13649
|
totalHarnesses?: number;
|
|
12766
|
-
blockedArtifacts?: number;
|
|
12767
13650
|
reviewArtifacts?: number;
|
|
12768
13651
|
}>;
|
|
12769
13652
|
items: z.ZodArray<z.ZodObject<{
|
|
@@ -12782,14 +13665,14 @@ declare const guardAbomResponseSchema: z.ZodObject<{
|
|
|
12782
13665
|
latestHash: z.ZodString;
|
|
12783
13666
|
latestSummary: z.ZodString;
|
|
12784
13667
|
}, "strip", z.ZodTypeAny, {
|
|
13668
|
+
artifactType?: "skill" | "plugin";
|
|
12785
13669
|
artifactId?: string;
|
|
12786
13670
|
artifactName?: string;
|
|
12787
|
-
artifactType?: "skill" | "plugin";
|
|
12788
13671
|
artifactSlug?: string;
|
|
12789
13672
|
publisher?: string;
|
|
13673
|
+
firstSeenAt?: string;
|
|
12790
13674
|
harnesses?: string[];
|
|
12791
13675
|
eventCount?: number;
|
|
12792
|
-
firstSeenAt?: string;
|
|
12793
13676
|
lastSeenAt?: string;
|
|
12794
13677
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12795
13678
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12797,14 +13680,14 @@ declare const guardAbomResponseSchema: z.ZodObject<{
|
|
|
12797
13680
|
latestHash?: string;
|
|
12798
13681
|
latestSummary?: string;
|
|
12799
13682
|
}, {
|
|
13683
|
+
artifactType?: "skill" | "plugin";
|
|
12800
13684
|
artifactId?: string;
|
|
12801
13685
|
artifactName?: string;
|
|
12802
|
-
artifactType?: "skill" | "plugin";
|
|
12803
13686
|
artifactSlug?: string;
|
|
12804
13687
|
publisher?: string;
|
|
13688
|
+
firstSeenAt?: string;
|
|
12805
13689
|
harnesses?: string[];
|
|
12806
13690
|
eventCount?: number;
|
|
12807
|
-
firstSeenAt?: string;
|
|
12808
13691
|
lastSeenAt?: string;
|
|
12809
13692
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12810
13693
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12814,21 +13697,21 @@ declare const guardAbomResponseSchema: z.ZodObject<{
|
|
|
12814
13697
|
}>, "many">;
|
|
12815
13698
|
}, "strip", z.ZodTypeAny, {
|
|
12816
13699
|
summary?: {
|
|
13700
|
+
blockedArtifacts?: number;
|
|
12817
13701
|
totalArtifacts?: number;
|
|
12818
13702
|
totalDevices?: number;
|
|
12819
13703
|
totalHarnesses?: number;
|
|
12820
|
-
blockedArtifacts?: number;
|
|
12821
13704
|
reviewArtifacts?: number;
|
|
12822
13705
|
};
|
|
12823
13706
|
items?: {
|
|
13707
|
+
artifactType?: "skill" | "plugin";
|
|
12824
13708
|
artifactId?: string;
|
|
12825
13709
|
artifactName?: string;
|
|
12826
|
-
artifactType?: "skill" | "plugin";
|
|
12827
13710
|
artifactSlug?: string;
|
|
12828
13711
|
publisher?: string;
|
|
13712
|
+
firstSeenAt?: string;
|
|
12829
13713
|
harnesses?: string[];
|
|
12830
13714
|
eventCount?: number;
|
|
12831
|
-
firstSeenAt?: string;
|
|
12832
13715
|
lastSeenAt?: string;
|
|
12833
13716
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12834
13717
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12839,21 +13722,21 @@ declare const guardAbomResponseSchema: z.ZodObject<{
|
|
|
12839
13722
|
generatedAt?: string;
|
|
12840
13723
|
}, {
|
|
12841
13724
|
summary?: {
|
|
13725
|
+
blockedArtifacts?: number;
|
|
12842
13726
|
totalArtifacts?: number;
|
|
12843
13727
|
totalDevices?: number;
|
|
12844
13728
|
totalHarnesses?: number;
|
|
12845
|
-
blockedArtifacts?: number;
|
|
12846
13729
|
reviewArtifacts?: number;
|
|
12847
13730
|
};
|
|
12848
13731
|
items?: {
|
|
13732
|
+
artifactType?: "skill" | "plugin";
|
|
12849
13733
|
artifactId?: string;
|
|
12850
13734
|
artifactName?: string;
|
|
12851
|
-
artifactType?: "skill" | "plugin";
|
|
12852
13735
|
artifactSlug?: string;
|
|
12853
13736
|
publisher?: string;
|
|
13737
|
+
firstSeenAt?: string;
|
|
12854
13738
|
harnesses?: string[];
|
|
12855
13739
|
eventCount?: number;
|
|
12856
|
-
firstSeenAt?: string;
|
|
12857
13740
|
lastSeenAt?: string;
|
|
12858
13741
|
latestDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12859
13742
|
latestRecommendation?: "monitor" | "review" | "block";
|
|
@@ -12880,6 +13763,7 @@ declare const guardTimelineEventSchema: z.ZodObject<{
|
|
|
12880
13763
|
capabilities?: string[];
|
|
12881
13764
|
summary?: string;
|
|
12882
13765
|
recommendation?: "monitor" | "review" | "block";
|
|
13766
|
+
publisher?: string;
|
|
12883
13767
|
receiptId?: string;
|
|
12884
13768
|
capturedAt?: string;
|
|
12885
13769
|
harness?: string;
|
|
@@ -12888,11 +13772,11 @@ declare const guardTimelineEventSchema: z.ZodObject<{
|
|
|
12888
13772
|
artifactHash?: string;
|
|
12889
13773
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12890
13774
|
changedSinceLastApproval?: boolean;
|
|
12891
|
-
publisher?: string;
|
|
12892
13775
|
}, {
|
|
12893
13776
|
capabilities?: string[];
|
|
12894
13777
|
summary?: string;
|
|
12895
13778
|
recommendation?: "monitor" | "review" | "block";
|
|
13779
|
+
publisher?: string;
|
|
12896
13780
|
receiptId?: string;
|
|
12897
13781
|
capturedAt?: string;
|
|
12898
13782
|
harness?: string;
|
|
@@ -12901,7 +13785,6 @@ declare const guardTimelineEventSchema: z.ZodObject<{
|
|
|
12901
13785
|
artifactHash?: string;
|
|
12902
13786
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12903
13787
|
changedSinceLastApproval?: boolean;
|
|
12904
|
-
publisher?: string;
|
|
12905
13788
|
}>;
|
|
12906
13789
|
declare const guardArtifactTimelineResponseSchema: z.ZodObject<{
|
|
12907
13790
|
generatedAt: z.ZodString;
|
|
@@ -12926,6 +13809,7 @@ declare const guardArtifactTimelineResponseSchema: z.ZodObject<{
|
|
|
12926
13809
|
capabilities?: string[];
|
|
12927
13810
|
summary?: string;
|
|
12928
13811
|
recommendation?: "monitor" | "review" | "block";
|
|
13812
|
+
publisher?: string;
|
|
12929
13813
|
receiptId?: string;
|
|
12930
13814
|
capturedAt?: string;
|
|
12931
13815
|
harness?: string;
|
|
@@ -12934,11 +13818,11 @@ declare const guardArtifactTimelineResponseSchema: z.ZodObject<{
|
|
|
12934
13818
|
artifactHash?: string;
|
|
12935
13819
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12936
13820
|
changedSinceLastApproval?: boolean;
|
|
12937
|
-
publisher?: string;
|
|
12938
13821
|
}, {
|
|
12939
13822
|
capabilities?: string[];
|
|
12940
13823
|
summary?: string;
|
|
12941
13824
|
recommendation?: "monitor" | "review" | "block";
|
|
13825
|
+
publisher?: string;
|
|
12942
13826
|
receiptId?: string;
|
|
12943
13827
|
capturedAt?: string;
|
|
12944
13828
|
harness?: string;
|
|
@@ -12947,18 +13831,18 @@ declare const guardArtifactTimelineResponseSchema: z.ZodObject<{
|
|
|
12947
13831
|
artifactHash?: string;
|
|
12948
13832
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12949
13833
|
changedSinceLastApproval?: boolean;
|
|
12950
|
-
publisher?: string;
|
|
12951
13834
|
}>, "many">;
|
|
12952
13835
|
}, "strip", z.ZodTypeAny, {
|
|
12953
13836
|
generatedAt?: string;
|
|
13837
|
+
artifactType?: "skill" | "plugin";
|
|
12954
13838
|
artifactId?: string;
|
|
12955
13839
|
artifactName?: string;
|
|
12956
|
-
artifactType?: "skill" | "plugin";
|
|
12957
13840
|
artifactSlug?: string;
|
|
12958
13841
|
events?: {
|
|
12959
13842
|
capabilities?: string[];
|
|
12960
13843
|
summary?: string;
|
|
12961
13844
|
recommendation?: "monitor" | "review" | "block";
|
|
13845
|
+
publisher?: string;
|
|
12962
13846
|
receiptId?: string;
|
|
12963
13847
|
capturedAt?: string;
|
|
12964
13848
|
harness?: string;
|
|
@@ -12967,18 +13851,18 @@ declare const guardArtifactTimelineResponseSchema: z.ZodObject<{
|
|
|
12967
13851
|
artifactHash?: string;
|
|
12968
13852
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12969
13853
|
changedSinceLastApproval?: boolean;
|
|
12970
|
-
publisher?: string;
|
|
12971
13854
|
}[];
|
|
12972
13855
|
}, {
|
|
12973
13856
|
generatedAt?: string;
|
|
13857
|
+
artifactType?: "skill" | "plugin";
|
|
12974
13858
|
artifactId?: string;
|
|
12975
13859
|
artifactName?: string;
|
|
12976
|
-
artifactType?: "skill" | "plugin";
|
|
12977
13860
|
artifactSlug?: string;
|
|
12978
13861
|
events?: {
|
|
12979
13862
|
capabilities?: string[];
|
|
12980
13863
|
summary?: string;
|
|
12981
13864
|
recommendation?: "monitor" | "review" | "block";
|
|
13865
|
+
publisher?: string;
|
|
12982
13866
|
receiptId?: string;
|
|
12983
13867
|
capturedAt?: string;
|
|
12984
13868
|
harness?: string;
|
|
@@ -12987,7 +13871,6 @@ declare const guardArtifactTimelineResponseSchema: z.ZodObject<{
|
|
|
12987
13871
|
artifactHash?: string;
|
|
12988
13872
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
12989
13873
|
changedSinceLastApproval?: boolean;
|
|
12990
|
-
publisher?: string;
|
|
12991
13874
|
}[];
|
|
12992
13875
|
}>;
|
|
12993
13876
|
declare const guardReceiptExportSummarySchema: z.ZodObject<{
|
|
@@ -12996,14 +13879,14 @@ declare const guardReceiptExportSummarySchema: z.ZodObject<{
|
|
|
12996
13879
|
reviewCount: z.ZodNumber;
|
|
12997
13880
|
approvedCount: z.ZodNumber;
|
|
12998
13881
|
}, "strip", z.ZodTypeAny, {
|
|
13882
|
+
reviewCount?: number;
|
|
12999
13883
|
totalReceipts?: number;
|
|
13000
13884
|
blockedCount?: number;
|
|
13001
|
-
reviewCount?: number;
|
|
13002
13885
|
approvedCount?: number;
|
|
13003
13886
|
}, {
|
|
13887
|
+
reviewCount?: number;
|
|
13004
13888
|
totalReceipts?: number;
|
|
13005
13889
|
blockedCount?: number;
|
|
13006
|
-
reviewCount?: number;
|
|
13007
13890
|
approvedCount?: number;
|
|
13008
13891
|
}>;
|
|
13009
13892
|
declare const guardExportSignatureSchema: z.ZodObject<{
|
|
@@ -13024,14 +13907,14 @@ declare const guardReceiptExportResponseSchema: z.ZodObject<{
|
|
|
13024
13907
|
reviewCount: z.ZodNumber;
|
|
13025
13908
|
approvedCount: z.ZodNumber;
|
|
13026
13909
|
}, "strip", z.ZodTypeAny, {
|
|
13910
|
+
reviewCount?: number;
|
|
13027
13911
|
totalReceipts?: number;
|
|
13028
13912
|
blockedCount?: number;
|
|
13029
|
-
reviewCount?: number;
|
|
13030
13913
|
approvedCount?: number;
|
|
13031
13914
|
}, {
|
|
13915
|
+
reviewCount?: number;
|
|
13032
13916
|
totalReceipts?: number;
|
|
13033
13917
|
blockedCount?: number;
|
|
13034
|
-
reviewCount?: number;
|
|
13035
13918
|
approvedCount?: number;
|
|
13036
13919
|
}>;
|
|
13037
13920
|
provenanceSummary: z.ZodArray<z.ZodString, "many">;
|
|
@@ -13056,10 +13939,11 @@ declare const guardReceiptExportResponseSchema: z.ZodObject<{
|
|
|
13056
13939
|
capabilities?: string[];
|
|
13057
13940
|
summary?: string;
|
|
13058
13941
|
recommendation?: "monitor" | "review" | "block";
|
|
13942
|
+
artifactType?: "skill" | "plugin";
|
|
13059
13943
|
artifactId?: string;
|
|
13060
13944
|
artifactName?: string;
|
|
13061
|
-
artifactType?: "skill" | "plugin";
|
|
13062
13945
|
artifactSlug?: string;
|
|
13946
|
+
publisher?: string;
|
|
13063
13947
|
receiptId?: string;
|
|
13064
13948
|
capturedAt?: string;
|
|
13065
13949
|
harness?: string;
|
|
@@ -13068,15 +13952,15 @@ declare const guardReceiptExportResponseSchema: z.ZodObject<{
|
|
|
13068
13952
|
artifactHash?: string;
|
|
13069
13953
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
13070
13954
|
changedSinceLastApproval?: boolean;
|
|
13071
|
-
publisher?: string;
|
|
13072
13955
|
}, {
|
|
13073
13956
|
capabilities?: string[];
|
|
13074
13957
|
summary?: string;
|
|
13075
13958
|
recommendation?: "monitor" | "review" | "block";
|
|
13959
|
+
artifactType?: "skill" | "plugin";
|
|
13076
13960
|
artifactId?: string;
|
|
13077
13961
|
artifactName?: string;
|
|
13078
|
-
artifactType?: "skill" | "plugin";
|
|
13079
13962
|
artifactSlug?: string;
|
|
13963
|
+
publisher?: string;
|
|
13080
13964
|
receiptId?: string;
|
|
13081
13965
|
capturedAt?: string;
|
|
13082
13966
|
harness?: string;
|
|
@@ -13085,7 +13969,6 @@ declare const guardReceiptExportResponseSchema: z.ZodObject<{
|
|
|
13085
13969
|
artifactHash?: string;
|
|
13086
13970
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
13087
13971
|
changedSinceLastApproval?: boolean;
|
|
13088
|
-
publisher?: string;
|
|
13089
13972
|
}>, "many">;
|
|
13090
13973
|
signature: z.ZodObject<{
|
|
13091
13974
|
algorithm: z.ZodEnum<["hmac-sha256", "none"]>;
|
|
@@ -13103,19 +13986,20 @@ declare const guardReceiptExportResponseSchema: z.ZodObject<{
|
|
|
13103
13986
|
algorithm?: "none" | "hmac-sha256";
|
|
13104
13987
|
};
|
|
13105
13988
|
summary?: {
|
|
13989
|
+
reviewCount?: number;
|
|
13106
13990
|
totalReceipts?: number;
|
|
13107
13991
|
blockedCount?: number;
|
|
13108
|
-
reviewCount?: number;
|
|
13109
13992
|
approvedCount?: number;
|
|
13110
13993
|
};
|
|
13111
13994
|
items?: {
|
|
13112
13995
|
capabilities?: string[];
|
|
13113
13996
|
summary?: string;
|
|
13114
13997
|
recommendation?: "monitor" | "review" | "block";
|
|
13998
|
+
artifactType?: "skill" | "plugin";
|
|
13115
13999
|
artifactId?: string;
|
|
13116
14000
|
artifactName?: string;
|
|
13117
|
-
artifactType?: "skill" | "plugin";
|
|
13118
14001
|
artifactSlug?: string;
|
|
14002
|
+
publisher?: string;
|
|
13119
14003
|
receiptId?: string;
|
|
13120
14004
|
capturedAt?: string;
|
|
13121
14005
|
harness?: string;
|
|
@@ -13124,7 +14008,6 @@ declare const guardReceiptExportResponseSchema: z.ZodObject<{
|
|
|
13124
14008
|
artifactHash?: string;
|
|
13125
14009
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
13126
14010
|
changedSinceLastApproval?: boolean;
|
|
13127
|
-
publisher?: string;
|
|
13128
14011
|
}[];
|
|
13129
14012
|
generatedAt?: string;
|
|
13130
14013
|
provenanceSummary?: string[];
|
|
@@ -13134,19 +14017,20 @@ declare const guardReceiptExportResponseSchema: z.ZodObject<{
|
|
|
13134
14017
|
algorithm?: "none" | "hmac-sha256";
|
|
13135
14018
|
};
|
|
13136
14019
|
summary?: {
|
|
14020
|
+
reviewCount?: number;
|
|
13137
14021
|
totalReceipts?: number;
|
|
13138
14022
|
blockedCount?: number;
|
|
13139
|
-
reviewCount?: number;
|
|
13140
14023
|
approvedCount?: number;
|
|
13141
14024
|
};
|
|
13142
14025
|
items?: {
|
|
13143
14026
|
capabilities?: string[];
|
|
13144
14027
|
summary?: string;
|
|
13145
14028
|
recommendation?: "monitor" | "review" | "block";
|
|
14029
|
+
artifactType?: "skill" | "plugin";
|
|
13146
14030
|
artifactId?: string;
|
|
13147
14031
|
artifactName?: string;
|
|
13148
|
-
artifactType?: "skill" | "plugin";
|
|
13149
14032
|
artifactSlug?: string;
|
|
14033
|
+
publisher?: string;
|
|
13150
14034
|
receiptId?: string;
|
|
13151
14035
|
capturedAt?: string;
|
|
13152
14036
|
harness?: string;
|
|
@@ -13155,7 +14039,6 @@ declare const guardReceiptExportResponseSchema: z.ZodObject<{
|
|
|
13155
14039
|
artifactHash?: string;
|
|
13156
14040
|
policyDecision?: "warn" | "review" | "block" | "allow" | "require-reapproval" | "sandbox-required";
|
|
13157
14041
|
changedSinceLastApproval?: boolean;
|
|
13158
|
-
publisher?: string;
|
|
13159
14042
|
}[];
|
|
13160
14043
|
generatedAt?: string;
|
|
13161
14044
|
provenanceSummary?: string[];
|
|
@@ -13196,19 +14079,19 @@ declare const guardWatchlistItemSchema: z.ZodObject<{
|
|
|
13196
14079
|
}, "strip", z.ZodTypeAny, {
|
|
13197
14080
|
reason?: string;
|
|
13198
14081
|
createdAt?: string;
|
|
14082
|
+
artifactType?: "skill" | "plugin";
|
|
13199
14083
|
artifactId?: string;
|
|
13200
14084
|
artifactName?: string;
|
|
13201
|
-
artifactType?: "skill" | "plugin";
|
|
13202
14085
|
artifactSlug?: string;
|
|
13203
|
-
source?: "manual" | "
|
|
14086
|
+
source?: "manual" | "team-policy" | "synced";
|
|
13204
14087
|
}, {
|
|
13205
14088
|
reason?: string;
|
|
13206
14089
|
createdAt?: string;
|
|
14090
|
+
artifactType?: "skill" | "plugin";
|
|
13207
14091
|
artifactId?: string;
|
|
13208
14092
|
artifactName?: string;
|
|
13209
|
-
artifactType?: "skill" | "plugin";
|
|
13210
14093
|
artifactSlug?: string;
|
|
13211
|
-
source?: "manual" | "
|
|
14094
|
+
source?: "manual" | "team-policy" | "synced";
|
|
13212
14095
|
}>;
|
|
13213
14096
|
declare const guardWatchlistResponseSchema: z.ZodObject<{
|
|
13214
14097
|
generatedAt: z.ZodString;
|
|
@@ -13221,42 +14104,333 @@ declare const guardWatchlistResponseSchema: z.ZodObject<{
|
|
|
13221
14104
|
source: z.ZodEnum<["manual", "synced", "team-policy"]>;
|
|
13222
14105
|
createdAt: z.ZodString;
|
|
13223
14106
|
}, "strip", z.ZodTypeAny, {
|
|
13224
|
-
reason?: string;
|
|
13225
|
-
createdAt?: string;
|
|
14107
|
+
reason?: string;
|
|
14108
|
+
createdAt?: string;
|
|
14109
|
+
artifactType?: "skill" | "plugin";
|
|
14110
|
+
artifactId?: string;
|
|
14111
|
+
artifactName?: string;
|
|
14112
|
+
artifactSlug?: string;
|
|
14113
|
+
source?: "manual" | "team-policy" | "synced";
|
|
14114
|
+
}, {
|
|
14115
|
+
reason?: string;
|
|
14116
|
+
createdAt?: string;
|
|
14117
|
+
artifactType?: "skill" | "plugin";
|
|
14118
|
+
artifactId?: string;
|
|
14119
|
+
artifactName?: string;
|
|
14120
|
+
artifactSlug?: string;
|
|
14121
|
+
source?: "manual" | "team-policy" | "synced";
|
|
14122
|
+
}>, "many">;
|
|
14123
|
+
}, "strip", z.ZodTypeAny, {
|
|
14124
|
+
items?: {
|
|
14125
|
+
reason?: string;
|
|
14126
|
+
createdAt?: string;
|
|
14127
|
+
artifactType?: "skill" | "plugin";
|
|
14128
|
+
artifactId?: string;
|
|
14129
|
+
artifactName?: string;
|
|
14130
|
+
artifactSlug?: string;
|
|
14131
|
+
source?: "manual" | "team-policy" | "synced";
|
|
14132
|
+
}[];
|
|
14133
|
+
generatedAt?: string;
|
|
14134
|
+
}, {
|
|
14135
|
+
items?: {
|
|
14136
|
+
reason?: string;
|
|
14137
|
+
createdAt?: string;
|
|
14138
|
+
artifactType?: "skill" | "plugin";
|
|
14139
|
+
artifactId?: string;
|
|
14140
|
+
artifactName?: string;
|
|
14141
|
+
artifactSlug?: string;
|
|
14142
|
+
source?: "manual" | "team-policy" | "synced";
|
|
14143
|
+
}[];
|
|
14144
|
+
generatedAt?: string;
|
|
14145
|
+
}>;
|
|
14146
|
+
declare const guardWatchlistLookupResponseSchema: z.ZodObject<{
|
|
14147
|
+
generatedAt: z.ZodString;
|
|
14148
|
+
matched: z.ZodBoolean;
|
|
14149
|
+
scope: z.ZodEnum<["artifact", "publisher", "domain", "none"]>;
|
|
14150
|
+
item: z.ZodNullable<z.ZodObject<{
|
|
14151
|
+
artifactId: z.ZodNullable<z.ZodString>;
|
|
14152
|
+
publisher: z.ZodNullable<z.ZodString>;
|
|
14153
|
+
domain: z.ZodNullable<z.ZodString>;
|
|
14154
|
+
source: z.ZodEnum<["watchlist", "team-policy"]>;
|
|
14155
|
+
reason: z.ZodString;
|
|
14156
|
+
}, "strip", z.ZodTypeAny, {
|
|
14157
|
+
reason?: string;
|
|
14158
|
+
domain?: string;
|
|
14159
|
+
artifactId?: string;
|
|
14160
|
+
publisher?: string;
|
|
14161
|
+
source?: "team-policy" | "watchlist";
|
|
14162
|
+
}, {
|
|
14163
|
+
reason?: string;
|
|
14164
|
+
domain?: string;
|
|
14165
|
+
artifactId?: string;
|
|
14166
|
+
publisher?: string;
|
|
14167
|
+
source?: "team-policy" | "watchlist";
|
|
14168
|
+
}>>;
|
|
14169
|
+
}, "strip", z.ZodTypeAny, {
|
|
14170
|
+
generatedAt?: string;
|
|
14171
|
+
scope?: "none" | "domain" | "artifact" | "publisher";
|
|
14172
|
+
matched?: boolean;
|
|
14173
|
+
item?: {
|
|
14174
|
+
reason?: string;
|
|
14175
|
+
domain?: string;
|
|
14176
|
+
artifactId?: string;
|
|
14177
|
+
publisher?: string;
|
|
14178
|
+
source?: "team-policy" | "watchlist";
|
|
14179
|
+
};
|
|
14180
|
+
}, {
|
|
14181
|
+
generatedAt?: string;
|
|
14182
|
+
scope?: "none" | "domain" | "artifact" | "publisher";
|
|
14183
|
+
matched?: boolean;
|
|
14184
|
+
item?: {
|
|
14185
|
+
reason?: string;
|
|
14186
|
+
domain?: string;
|
|
14187
|
+
artifactId?: string;
|
|
14188
|
+
publisher?: string;
|
|
14189
|
+
source?: "team-policy" | "watchlist";
|
|
14190
|
+
};
|
|
14191
|
+
}>;
|
|
14192
|
+
declare const guardPainSignalSchema: z.ZodObject<{
|
|
14193
|
+
signalId: z.ZodString;
|
|
14194
|
+
signalName: z.ZodString;
|
|
14195
|
+
artifactId: z.ZodString;
|
|
14196
|
+
artifactName: z.ZodString;
|
|
14197
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
14198
|
+
harness: z.ZodString;
|
|
14199
|
+
latestSummary: z.ZodString;
|
|
14200
|
+
firstSeenAt: z.ZodString;
|
|
14201
|
+
lastSeenAt: z.ZodString;
|
|
14202
|
+
count: z.ZodNumber;
|
|
14203
|
+
source: z.ZodLiteral<"scanner">;
|
|
14204
|
+
publisher: z.ZodOptional<z.ZodString>;
|
|
14205
|
+
}, "strip", z.ZodTypeAny, {
|
|
14206
|
+
artifactType?: "skill" | "plugin";
|
|
14207
|
+
artifactId?: string;
|
|
14208
|
+
artifactName?: string;
|
|
14209
|
+
publisher?: string;
|
|
14210
|
+
source?: "scanner";
|
|
14211
|
+
firstSeenAt?: string;
|
|
14212
|
+
harness?: string;
|
|
14213
|
+
lastSeenAt?: string;
|
|
14214
|
+
latestSummary?: string;
|
|
14215
|
+
signalId?: string;
|
|
14216
|
+
signalName?: string;
|
|
14217
|
+
count?: number;
|
|
14218
|
+
}, {
|
|
14219
|
+
artifactType?: "skill" | "plugin";
|
|
14220
|
+
artifactId?: string;
|
|
14221
|
+
artifactName?: string;
|
|
14222
|
+
publisher?: string;
|
|
14223
|
+
source?: "scanner";
|
|
14224
|
+
firstSeenAt?: string;
|
|
14225
|
+
harness?: string;
|
|
14226
|
+
lastSeenAt?: string;
|
|
14227
|
+
latestSummary?: string;
|
|
14228
|
+
signalId?: string;
|
|
14229
|
+
signalName?: string;
|
|
14230
|
+
count?: number;
|
|
14231
|
+
}>;
|
|
14232
|
+
declare const guardPainSignalListResponseSchema: z.ZodObject<{
|
|
14233
|
+
generatedAt: z.ZodString;
|
|
14234
|
+
items: z.ZodArray<z.ZodObject<{
|
|
14235
|
+
signalId: z.ZodString;
|
|
14236
|
+
signalName: z.ZodString;
|
|
14237
|
+
artifactId: z.ZodString;
|
|
14238
|
+
artifactName: z.ZodString;
|
|
14239
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
14240
|
+
harness: z.ZodString;
|
|
14241
|
+
latestSummary: z.ZodString;
|
|
14242
|
+
firstSeenAt: z.ZodString;
|
|
14243
|
+
lastSeenAt: z.ZodString;
|
|
14244
|
+
count: z.ZodNumber;
|
|
14245
|
+
source: z.ZodLiteral<"scanner">;
|
|
14246
|
+
publisher: z.ZodOptional<z.ZodString>;
|
|
14247
|
+
}, "strip", z.ZodTypeAny, {
|
|
14248
|
+
artifactType?: "skill" | "plugin";
|
|
14249
|
+
artifactId?: string;
|
|
14250
|
+
artifactName?: string;
|
|
14251
|
+
publisher?: string;
|
|
14252
|
+
source?: "scanner";
|
|
14253
|
+
firstSeenAt?: string;
|
|
14254
|
+
harness?: string;
|
|
14255
|
+
lastSeenAt?: string;
|
|
14256
|
+
latestSummary?: string;
|
|
14257
|
+
signalId?: string;
|
|
14258
|
+
signalName?: string;
|
|
14259
|
+
count?: number;
|
|
14260
|
+
}, {
|
|
14261
|
+
artifactType?: "skill" | "plugin";
|
|
14262
|
+
artifactId?: string;
|
|
14263
|
+
artifactName?: string;
|
|
14264
|
+
publisher?: string;
|
|
14265
|
+
source?: "scanner";
|
|
14266
|
+
firstSeenAt?: string;
|
|
14267
|
+
harness?: string;
|
|
14268
|
+
lastSeenAt?: string;
|
|
14269
|
+
latestSummary?: string;
|
|
14270
|
+
signalId?: string;
|
|
14271
|
+
signalName?: string;
|
|
14272
|
+
count?: number;
|
|
14273
|
+
}>, "many">;
|
|
14274
|
+
}, "strip", z.ZodTypeAny, {
|
|
14275
|
+
items?: {
|
|
14276
|
+
artifactType?: "skill" | "plugin";
|
|
14277
|
+
artifactId?: string;
|
|
14278
|
+
artifactName?: string;
|
|
14279
|
+
publisher?: string;
|
|
14280
|
+
source?: "scanner";
|
|
14281
|
+
firstSeenAt?: string;
|
|
14282
|
+
harness?: string;
|
|
14283
|
+
lastSeenAt?: string;
|
|
14284
|
+
latestSummary?: string;
|
|
14285
|
+
signalId?: string;
|
|
14286
|
+
signalName?: string;
|
|
14287
|
+
count?: number;
|
|
14288
|
+
}[];
|
|
14289
|
+
generatedAt?: string;
|
|
14290
|
+
}, {
|
|
14291
|
+
items?: {
|
|
14292
|
+
artifactType?: "skill" | "plugin";
|
|
14293
|
+
artifactId?: string;
|
|
14294
|
+
artifactName?: string;
|
|
14295
|
+
publisher?: string;
|
|
14296
|
+
source?: "scanner";
|
|
14297
|
+
firstSeenAt?: string;
|
|
14298
|
+
harness?: string;
|
|
14299
|
+
lastSeenAt?: string;
|
|
14300
|
+
latestSummary?: string;
|
|
14301
|
+
signalId?: string;
|
|
14302
|
+
signalName?: string;
|
|
14303
|
+
count?: number;
|
|
14304
|
+
}[];
|
|
14305
|
+
generatedAt?: string;
|
|
14306
|
+
}>;
|
|
14307
|
+
declare const guardPainSignalAggregateSchema: z.ZodObject<{
|
|
14308
|
+
artifactId: z.ZodString;
|
|
14309
|
+
artifactName: z.ZodString;
|
|
14310
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
14311
|
+
signalName: z.ZodString;
|
|
14312
|
+
latestSummary: z.ZodString;
|
|
14313
|
+
firstSeenAt: z.ZodString;
|
|
14314
|
+
lastSeenAt: z.ZodString;
|
|
14315
|
+
totalCount: z.ZodNumber;
|
|
14316
|
+
consumerCount: z.ZodNumber;
|
|
14317
|
+
harnesses: z.ZodArray<z.ZodString, "many">;
|
|
14318
|
+
publishers: z.ZodArray<z.ZodString, "many">;
|
|
14319
|
+
}, "strip", z.ZodTypeAny, {
|
|
14320
|
+
artifactType?: "skill" | "plugin";
|
|
14321
|
+
artifactId?: string;
|
|
14322
|
+
artifactName?: string;
|
|
14323
|
+
firstSeenAt?: string;
|
|
14324
|
+
harnesses?: string[];
|
|
14325
|
+
lastSeenAt?: string;
|
|
14326
|
+
latestSummary?: string;
|
|
14327
|
+
signalName?: string;
|
|
14328
|
+
totalCount?: number;
|
|
14329
|
+
consumerCount?: number;
|
|
14330
|
+
publishers?: string[];
|
|
14331
|
+
}, {
|
|
14332
|
+
artifactType?: "skill" | "plugin";
|
|
14333
|
+
artifactId?: string;
|
|
14334
|
+
artifactName?: string;
|
|
14335
|
+
firstSeenAt?: string;
|
|
14336
|
+
harnesses?: string[];
|
|
14337
|
+
lastSeenAt?: string;
|
|
14338
|
+
latestSummary?: string;
|
|
14339
|
+
signalName?: string;
|
|
14340
|
+
totalCount?: number;
|
|
14341
|
+
consumerCount?: number;
|
|
14342
|
+
publishers?: string[];
|
|
14343
|
+
}>;
|
|
14344
|
+
declare const guardPainSignalAggregateResponseSchema: z.ZodObject<{
|
|
14345
|
+
generatedAt: z.ZodString;
|
|
14346
|
+
summary: z.ZodObject<{
|
|
14347
|
+
totalSignals: z.ZodNumber;
|
|
14348
|
+
uniqueArtifacts: z.ZodNumber;
|
|
14349
|
+
uniqueConsumers: z.ZodNumber;
|
|
14350
|
+
}, "strip", z.ZodTypeAny, {
|
|
14351
|
+
totalSignals?: number;
|
|
14352
|
+
uniqueArtifacts?: number;
|
|
14353
|
+
uniqueConsumers?: number;
|
|
14354
|
+
}, {
|
|
14355
|
+
totalSignals?: number;
|
|
14356
|
+
uniqueArtifacts?: number;
|
|
14357
|
+
uniqueConsumers?: number;
|
|
14358
|
+
}>;
|
|
14359
|
+
items: z.ZodArray<z.ZodObject<{
|
|
14360
|
+
artifactId: z.ZodString;
|
|
14361
|
+
artifactName: z.ZodString;
|
|
14362
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
14363
|
+
signalName: z.ZodString;
|
|
14364
|
+
latestSummary: z.ZodString;
|
|
14365
|
+
firstSeenAt: z.ZodString;
|
|
14366
|
+
lastSeenAt: z.ZodString;
|
|
14367
|
+
totalCount: z.ZodNumber;
|
|
14368
|
+
consumerCount: z.ZodNumber;
|
|
14369
|
+
harnesses: z.ZodArray<z.ZodString, "many">;
|
|
14370
|
+
publishers: z.ZodArray<z.ZodString, "many">;
|
|
14371
|
+
}, "strip", z.ZodTypeAny, {
|
|
14372
|
+
artifactType?: "skill" | "plugin";
|
|
13226
14373
|
artifactId?: string;
|
|
13227
14374
|
artifactName?: string;
|
|
13228
|
-
|
|
13229
|
-
|
|
13230
|
-
|
|
14375
|
+
firstSeenAt?: string;
|
|
14376
|
+
harnesses?: string[];
|
|
14377
|
+
lastSeenAt?: string;
|
|
14378
|
+
latestSummary?: string;
|
|
14379
|
+
signalName?: string;
|
|
14380
|
+
totalCount?: number;
|
|
14381
|
+
consumerCount?: number;
|
|
14382
|
+
publishers?: string[];
|
|
13231
14383
|
}, {
|
|
13232
|
-
|
|
13233
|
-
createdAt?: string;
|
|
14384
|
+
artifactType?: "skill" | "plugin";
|
|
13234
14385
|
artifactId?: string;
|
|
13235
14386
|
artifactName?: string;
|
|
13236
|
-
|
|
13237
|
-
|
|
13238
|
-
|
|
14387
|
+
firstSeenAt?: string;
|
|
14388
|
+
harnesses?: string[];
|
|
14389
|
+
lastSeenAt?: string;
|
|
14390
|
+
latestSummary?: string;
|
|
14391
|
+
signalName?: string;
|
|
14392
|
+
totalCount?: number;
|
|
14393
|
+
consumerCount?: number;
|
|
14394
|
+
publishers?: string[];
|
|
13239
14395
|
}>, "many">;
|
|
13240
14396
|
}, "strip", z.ZodTypeAny, {
|
|
14397
|
+
summary?: {
|
|
14398
|
+
totalSignals?: number;
|
|
14399
|
+
uniqueArtifacts?: number;
|
|
14400
|
+
uniqueConsumers?: number;
|
|
14401
|
+
};
|
|
13241
14402
|
items?: {
|
|
13242
|
-
|
|
13243
|
-
createdAt?: string;
|
|
14403
|
+
artifactType?: "skill" | "plugin";
|
|
13244
14404
|
artifactId?: string;
|
|
13245
14405
|
artifactName?: string;
|
|
13246
|
-
|
|
13247
|
-
|
|
13248
|
-
|
|
14406
|
+
firstSeenAt?: string;
|
|
14407
|
+
harnesses?: string[];
|
|
14408
|
+
lastSeenAt?: string;
|
|
14409
|
+
latestSummary?: string;
|
|
14410
|
+
signalName?: string;
|
|
14411
|
+
totalCount?: number;
|
|
14412
|
+
consumerCount?: number;
|
|
14413
|
+
publishers?: string[];
|
|
13249
14414
|
}[];
|
|
13250
14415
|
generatedAt?: string;
|
|
13251
14416
|
}, {
|
|
14417
|
+
summary?: {
|
|
14418
|
+
totalSignals?: number;
|
|
14419
|
+
uniqueArtifacts?: number;
|
|
14420
|
+
uniqueConsumers?: number;
|
|
14421
|
+
};
|
|
13252
14422
|
items?: {
|
|
13253
|
-
|
|
13254
|
-
createdAt?: string;
|
|
14423
|
+
artifactType?: "skill" | "plugin";
|
|
13255
14424
|
artifactId?: string;
|
|
13256
14425
|
artifactName?: string;
|
|
13257
|
-
|
|
13258
|
-
|
|
13259
|
-
|
|
14426
|
+
firstSeenAt?: string;
|
|
14427
|
+
harnesses?: string[];
|
|
14428
|
+
lastSeenAt?: string;
|
|
14429
|
+
latestSummary?: string;
|
|
14430
|
+
signalName?: string;
|
|
14431
|
+
totalCount?: number;
|
|
14432
|
+
consumerCount?: number;
|
|
14433
|
+
publishers?: string[];
|
|
13260
14434
|
}[];
|
|
13261
14435
|
generatedAt?: string;
|
|
13262
14436
|
}>;
|
|
@@ -13279,11 +14453,11 @@ declare const guardExceptionItemSchema: z.ZodObject<{
|
|
|
13279
14453
|
updatedAt?: string;
|
|
13280
14454
|
expiresAt?: string;
|
|
13281
14455
|
artifactId?: string;
|
|
13282
|
-
harness?: string;
|
|
13283
14456
|
publisher?: string;
|
|
14457
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13284
14458
|
source?: "manual" | "team-policy";
|
|
14459
|
+
harness?: string;
|
|
13285
14460
|
exceptionId?: string;
|
|
13286
|
-
scope?: "harness" | "publisher" | "artifact" | "global";
|
|
13287
14461
|
}, {
|
|
13288
14462
|
reason?: string;
|
|
13289
14463
|
owner?: string;
|
|
@@ -13291,11 +14465,11 @@ declare const guardExceptionItemSchema: z.ZodObject<{
|
|
|
13291
14465
|
updatedAt?: string;
|
|
13292
14466
|
expiresAt?: string;
|
|
13293
14467
|
artifactId?: string;
|
|
13294
|
-
harness?: string;
|
|
13295
14468
|
publisher?: string;
|
|
14469
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13296
14470
|
source?: "manual" | "team-policy";
|
|
14471
|
+
harness?: string;
|
|
13297
14472
|
exceptionId?: string;
|
|
13298
|
-
scope?: "harness" | "publisher" | "artifact" | "global";
|
|
13299
14473
|
}>;
|
|
13300
14474
|
declare const guardExceptionListResponseSchema: z.ZodObject<{
|
|
13301
14475
|
generatedAt: z.ZodString;
|
|
@@ -13318,11 +14492,11 @@ declare const guardExceptionListResponseSchema: z.ZodObject<{
|
|
|
13318
14492
|
updatedAt?: string;
|
|
13319
14493
|
expiresAt?: string;
|
|
13320
14494
|
artifactId?: string;
|
|
13321
|
-
harness?: string;
|
|
13322
14495
|
publisher?: string;
|
|
14496
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13323
14497
|
source?: "manual" | "team-policy";
|
|
14498
|
+
harness?: string;
|
|
13324
14499
|
exceptionId?: string;
|
|
13325
|
-
scope?: "harness" | "publisher" | "artifact" | "global";
|
|
13326
14500
|
}, {
|
|
13327
14501
|
reason?: string;
|
|
13328
14502
|
owner?: string;
|
|
@@ -13330,11 +14504,11 @@ declare const guardExceptionListResponseSchema: z.ZodObject<{
|
|
|
13330
14504
|
updatedAt?: string;
|
|
13331
14505
|
expiresAt?: string;
|
|
13332
14506
|
artifactId?: string;
|
|
13333
|
-
harness?: string;
|
|
13334
14507
|
publisher?: string;
|
|
14508
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13335
14509
|
source?: "manual" | "team-policy";
|
|
14510
|
+
harness?: string;
|
|
13336
14511
|
exceptionId?: string;
|
|
13337
|
-
scope?: "harness" | "publisher" | "artifact" | "global";
|
|
13338
14512
|
}>, "many">;
|
|
13339
14513
|
}, "strip", z.ZodTypeAny, {
|
|
13340
14514
|
items?: {
|
|
@@ -13344,11 +14518,11 @@ declare const guardExceptionListResponseSchema: z.ZodObject<{
|
|
|
13344
14518
|
updatedAt?: string;
|
|
13345
14519
|
expiresAt?: string;
|
|
13346
14520
|
artifactId?: string;
|
|
13347
|
-
harness?: string;
|
|
13348
14521
|
publisher?: string;
|
|
14522
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13349
14523
|
source?: "manual" | "team-policy";
|
|
14524
|
+
harness?: string;
|
|
13350
14525
|
exceptionId?: string;
|
|
13351
|
-
scope?: "harness" | "publisher" | "artifact" | "global";
|
|
13352
14526
|
}[];
|
|
13353
14527
|
generatedAt?: string;
|
|
13354
14528
|
}, {
|
|
@@ -13359,13 +14533,296 @@ declare const guardExceptionListResponseSchema: z.ZodObject<{
|
|
|
13359
14533
|
updatedAt?: string;
|
|
13360
14534
|
expiresAt?: string;
|
|
13361
14535
|
artifactId?: string;
|
|
14536
|
+
publisher?: string;
|
|
14537
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
14538
|
+
source?: "manual" | "team-policy";
|
|
14539
|
+
harness?: string;
|
|
14540
|
+
exceptionId?: string;
|
|
14541
|
+
}[];
|
|
14542
|
+
generatedAt?: string;
|
|
14543
|
+
}>;
|
|
14544
|
+
declare const guardPreflightEvidenceSchema: z.ZodObject<{
|
|
14545
|
+
category: z.ZodEnum<["policy", "trust", "watchlist", "team-policy", "exception"]>;
|
|
14546
|
+
source: z.ZodString;
|
|
14547
|
+
detail: z.ZodString;
|
|
14548
|
+
}, "strip", z.ZodTypeAny, {
|
|
14549
|
+
source?: string;
|
|
14550
|
+
category?: "policy" | "team-policy" | "watchlist" | "trust" | "exception";
|
|
14551
|
+
detail?: string;
|
|
14552
|
+
}, {
|
|
14553
|
+
source?: string;
|
|
14554
|
+
category?: "policy" | "team-policy" | "watchlist" | "trust" | "exception";
|
|
14555
|
+
detail?: string;
|
|
14556
|
+
}>;
|
|
14557
|
+
declare const guardPreflightRequestSchema: z.ZodObject<{
|
|
14558
|
+
harness: z.ZodString;
|
|
14559
|
+
artifactName: z.ZodString;
|
|
14560
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
14561
|
+
artifactId: z.ZodOptional<z.ZodString>;
|
|
14562
|
+
artifactSlug: z.ZodOptional<z.ZodString>;
|
|
14563
|
+
artifactHash: z.ZodOptional<z.ZodString>;
|
|
14564
|
+
publisher: z.ZodOptional<z.ZodString>;
|
|
14565
|
+
domain: z.ZodOptional<z.ZodString>;
|
|
14566
|
+
launchSummary: z.ZodOptional<z.ZodString>;
|
|
14567
|
+
capabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
14568
|
+
workspacePath: z.ZodOptional<z.ZodString>;
|
|
14569
|
+
}, "strip", z.ZodTypeAny, {
|
|
14570
|
+
capabilities?: string[];
|
|
14571
|
+
domain?: string;
|
|
14572
|
+
artifactType?: "skill" | "plugin";
|
|
14573
|
+
artifactId?: string;
|
|
14574
|
+
artifactName?: string;
|
|
14575
|
+
artifactSlug?: string;
|
|
14576
|
+
publisher?: string;
|
|
14577
|
+
harness?: string;
|
|
14578
|
+
artifactHash?: string;
|
|
14579
|
+
launchSummary?: string;
|
|
14580
|
+
workspacePath?: string;
|
|
14581
|
+
}, {
|
|
14582
|
+
capabilities?: string[];
|
|
14583
|
+
domain?: string;
|
|
14584
|
+
artifactType?: "skill" | "plugin";
|
|
14585
|
+
artifactId?: string;
|
|
14586
|
+
artifactName?: string;
|
|
14587
|
+
artifactSlug?: string;
|
|
14588
|
+
publisher?: string;
|
|
14589
|
+
harness?: string;
|
|
14590
|
+
artifactHash?: string;
|
|
14591
|
+
launchSummary?: string;
|
|
14592
|
+
workspacePath?: string;
|
|
14593
|
+
}>;
|
|
14594
|
+
declare const guardPreflightVerdictResponseSchema: z.ZodObject<{
|
|
14595
|
+
generatedAt: z.ZodString;
|
|
14596
|
+
principal: z.ZodObject<{
|
|
14597
|
+
signedIn: z.ZodBoolean;
|
|
14598
|
+
principalType: z.ZodDefault<z.ZodEnum<["user", "service"]>>;
|
|
14599
|
+
userId: z.ZodOptional<z.ZodString>;
|
|
14600
|
+
email: z.ZodOptional<z.ZodString>;
|
|
14601
|
+
accountId: z.ZodOptional<z.ZodString>;
|
|
14602
|
+
stripeCustomerId: z.ZodOptional<z.ZodString>;
|
|
14603
|
+
serviceId: z.ZodOptional<z.ZodString>;
|
|
14604
|
+
workspaceId: z.ZodOptional<z.ZodString>;
|
|
14605
|
+
serviceLabel: z.ZodOptional<z.ZodString>;
|
|
14606
|
+
roles: z.ZodArray<z.ZodString, "many">;
|
|
14607
|
+
}, "strip", z.ZodTypeAny, {
|
|
14608
|
+
accountId?: string;
|
|
14609
|
+
userId?: string;
|
|
14610
|
+
email?: string;
|
|
14611
|
+
signedIn?: boolean;
|
|
14612
|
+
principalType?: "service" | "user";
|
|
14613
|
+
stripeCustomerId?: string;
|
|
14614
|
+
serviceId?: string;
|
|
14615
|
+
workspaceId?: string;
|
|
14616
|
+
serviceLabel?: string;
|
|
14617
|
+
roles?: string[];
|
|
14618
|
+
}, {
|
|
14619
|
+
accountId?: string;
|
|
14620
|
+
userId?: string;
|
|
14621
|
+
email?: string;
|
|
14622
|
+
signedIn?: boolean;
|
|
14623
|
+
principalType?: "service" | "user";
|
|
14624
|
+
stripeCustomerId?: string;
|
|
14625
|
+
serviceId?: string;
|
|
14626
|
+
workspaceId?: string;
|
|
14627
|
+
serviceLabel?: string;
|
|
14628
|
+
roles?: string[];
|
|
14629
|
+
}>;
|
|
14630
|
+
decision: z.ZodEnum<["allow", "review", "block"]>;
|
|
14631
|
+
recommendation: z.ZodEnum<["monitor", "review", "block"]>;
|
|
14632
|
+
rationale: z.ZodString;
|
|
14633
|
+
category: z.ZodOptional<z.ZodEnum<["exception", "team-policy", "watchlist", "trust", "policy"]>>;
|
|
14634
|
+
confidence: z.ZodOptional<z.ZodNumber>;
|
|
14635
|
+
freshnessTimestamp: z.ZodOptional<z.ZodString>;
|
|
14636
|
+
evidenceSources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
14637
|
+
scope: z.ZodEnum<["artifact", "publisher", "domain", "policy"]>;
|
|
14638
|
+
matchedEvidence: z.ZodArray<z.ZodObject<{
|
|
14639
|
+
category: z.ZodEnum<["policy", "trust", "watchlist", "team-policy", "exception"]>;
|
|
14640
|
+
source: z.ZodString;
|
|
14641
|
+
detail: z.ZodString;
|
|
14642
|
+
}, "strip", z.ZodTypeAny, {
|
|
14643
|
+
source?: string;
|
|
14644
|
+
category?: "policy" | "team-policy" | "watchlist" | "trust" | "exception";
|
|
14645
|
+
detail?: string;
|
|
14646
|
+
}, {
|
|
14647
|
+
source?: string;
|
|
14648
|
+
category?: "policy" | "team-policy" | "watchlist" | "trust" | "exception";
|
|
14649
|
+
detail?: string;
|
|
14650
|
+
}>, "many">;
|
|
14651
|
+
matchedException: z.ZodNullable<z.ZodObject<{
|
|
14652
|
+
exceptionId: z.ZodString;
|
|
14653
|
+
scope: z.ZodEnum<["artifact", "publisher", "harness", "global"]>;
|
|
14654
|
+
harness: z.ZodNullable<z.ZodString>;
|
|
14655
|
+
artifactId: z.ZodNullable<z.ZodString>;
|
|
14656
|
+
publisher: z.ZodNullable<z.ZodString>;
|
|
14657
|
+
reason: z.ZodString;
|
|
14658
|
+
owner: z.ZodString;
|
|
14659
|
+
source: z.ZodEnum<["manual", "team-policy"]>;
|
|
14660
|
+
expiresAt: z.ZodString;
|
|
14661
|
+
createdAt: z.ZodString;
|
|
14662
|
+
updatedAt: z.ZodString;
|
|
14663
|
+
}, "strip", z.ZodTypeAny, {
|
|
14664
|
+
reason?: string;
|
|
14665
|
+
owner?: string;
|
|
14666
|
+
createdAt?: string;
|
|
14667
|
+
updatedAt?: string;
|
|
14668
|
+
expiresAt?: string;
|
|
14669
|
+
artifactId?: string;
|
|
14670
|
+
publisher?: string;
|
|
14671
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
14672
|
+
source?: "manual" | "team-policy";
|
|
13362
14673
|
harness?: string;
|
|
14674
|
+
exceptionId?: string;
|
|
14675
|
+
}, {
|
|
14676
|
+
reason?: string;
|
|
14677
|
+
owner?: string;
|
|
14678
|
+
createdAt?: string;
|
|
14679
|
+
updatedAt?: string;
|
|
14680
|
+
expiresAt?: string;
|
|
14681
|
+
artifactId?: string;
|
|
13363
14682
|
publisher?: string;
|
|
14683
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
13364
14684
|
source?: "manual" | "team-policy";
|
|
14685
|
+
harness?: string;
|
|
13365
14686
|
exceptionId?: string;
|
|
13366
|
-
|
|
14687
|
+
}>>;
|
|
14688
|
+
trustMatch: z.ZodNullable<z.ZodObject<{
|
|
14689
|
+
artifactId: z.ZodString;
|
|
14690
|
+
artifactName: z.ZodString;
|
|
14691
|
+
artifactType: z.ZodEnum<["skill", "plugin"]>;
|
|
14692
|
+
artifactSlug: z.ZodString;
|
|
14693
|
+
recommendation: z.ZodEnum<["monitor", "review", "block"]>;
|
|
14694
|
+
verified: z.ZodBoolean;
|
|
14695
|
+
safetyScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
14696
|
+
trustScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
14697
|
+
href: z.ZodOptional<z.ZodString>;
|
|
14698
|
+
ecosystem: z.ZodOptional<z.ZodString>;
|
|
14699
|
+
}, "strip", z.ZodTypeAny, {
|
|
14700
|
+
recommendation?: "monitor" | "review" | "block";
|
|
14701
|
+
trustScore?: number;
|
|
14702
|
+
artifactType?: "skill" | "plugin";
|
|
14703
|
+
href?: string;
|
|
14704
|
+
ecosystem?: string;
|
|
14705
|
+
safetyScore?: number;
|
|
14706
|
+
verified?: boolean;
|
|
14707
|
+
artifactId?: string;
|
|
14708
|
+
artifactName?: string;
|
|
14709
|
+
artifactSlug?: string;
|
|
14710
|
+
}, {
|
|
14711
|
+
recommendation?: "monitor" | "review" | "block";
|
|
14712
|
+
trustScore?: number;
|
|
14713
|
+
artifactType?: "skill" | "plugin";
|
|
14714
|
+
href?: string;
|
|
14715
|
+
ecosystem?: string;
|
|
14716
|
+
safetyScore?: number;
|
|
14717
|
+
verified?: boolean;
|
|
14718
|
+
artifactId?: string;
|
|
14719
|
+
artifactName?: string;
|
|
14720
|
+
artifactSlug?: string;
|
|
14721
|
+
}>>;
|
|
14722
|
+
}, "strip", z.ZodTypeAny, {
|
|
14723
|
+
confidence?: number;
|
|
14724
|
+
recommendation?: "monitor" | "review" | "block";
|
|
14725
|
+
principal?: {
|
|
14726
|
+
accountId?: string;
|
|
14727
|
+
userId?: string;
|
|
14728
|
+
email?: string;
|
|
14729
|
+
signedIn?: boolean;
|
|
14730
|
+
principalType?: "service" | "user";
|
|
14731
|
+
stripeCustomerId?: string;
|
|
14732
|
+
serviceId?: string;
|
|
14733
|
+
workspaceId?: string;
|
|
14734
|
+
serviceLabel?: string;
|
|
14735
|
+
roles?: string[];
|
|
14736
|
+
};
|
|
14737
|
+
generatedAt?: string;
|
|
14738
|
+
scope?: "domain" | "artifact" | "publisher" | "policy";
|
|
14739
|
+
category?: "policy" | "team-policy" | "watchlist" | "trust" | "exception";
|
|
14740
|
+
decision?: "review" | "block" | "allow";
|
|
14741
|
+
rationale?: string;
|
|
14742
|
+
freshnessTimestamp?: string;
|
|
14743
|
+
evidenceSources?: string[];
|
|
14744
|
+
matchedEvidence?: {
|
|
14745
|
+
source?: string;
|
|
14746
|
+
category?: "policy" | "team-policy" | "watchlist" | "trust" | "exception";
|
|
14747
|
+
detail?: string;
|
|
13367
14748
|
}[];
|
|
14749
|
+
matchedException?: {
|
|
14750
|
+
reason?: string;
|
|
14751
|
+
owner?: string;
|
|
14752
|
+
createdAt?: string;
|
|
14753
|
+
updatedAt?: string;
|
|
14754
|
+
expiresAt?: string;
|
|
14755
|
+
artifactId?: string;
|
|
14756
|
+
publisher?: string;
|
|
14757
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
14758
|
+
source?: "manual" | "team-policy";
|
|
14759
|
+
harness?: string;
|
|
14760
|
+
exceptionId?: string;
|
|
14761
|
+
};
|
|
14762
|
+
trustMatch?: {
|
|
14763
|
+
recommendation?: "monitor" | "review" | "block";
|
|
14764
|
+
trustScore?: number;
|
|
14765
|
+
artifactType?: "skill" | "plugin";
|
|
14766
|
+
href?: string;
|
|
14767
|
+
ecosystem?: string;
|
|
14768
|
+
safetyScore?: number;
|
|
14769
|
+
verified?: boolean;
|
|
14770
|
+
artifactId?: string;
|
|
14771
|
+
artifactName?: string;
|
|
14772
|
+
artifactSlug?: string;
|
|
14773
|
+
};
|
|
14774
|
+
}, {
|
|
14775
|
+
confidence?: number;
|
|
14776
|
+
recommendation?: "monitor" | "review" | "block";
|
|
14777
|
+
principal?: {
|
|
14778
|
+
accountId?: string;
|
|
14779
|
+
userId?: string;
|
|
14780
|
+
email?: string;
|
|
14781
|
+
signedIn?: boolean;
|
|
14782
|
+
principalType?: "service" | "user";
|
|
14783
|
+
stripeCustomerId?: string;
|
|
14784
|
+
serviceId?: string;
|
|
14785
|
+
workspaceId?: string;
|
|
14786
|
+
serviceLabel?: string;
|
|
14787
|
+
roles?: string[];
|
|
14788
|
+
};
|
|
13368
14789
|
generatedAt?: string;
|
|
14790
|
+
scope?: "domain" | "artifact" | "publisher" | "policy";
|
|
14791
|
+
category?: "policy" | "team-policy" | "watchlist" | "trust" | "exception";
|
|
14792
|
+
decision?: "review" | "block" | "allow";
|
|
14793
|
+
rationale?: string;
|
|
14794
|
+
freshnessTimestamp?: string;
|
|
14795
|
+
evidenceSources?: string[];
|
|
14796
|
+
matchedEvidence?: {
|
|
14797
|
+
source?: string;
|
|
14798
|
+
category?: "policy" | "team-policy" | "watchlist" | "trust" | "exception";
|
|
14799
|
+
detail?: string;
|
|
14800
|
+
}[];
|
|
14801
|
+
matchedException?: {
|
|
14802
|
+
reason?: string;
|
|
14803
|
+
owner?: string;
|
|
14804
|
+
createdAt?: string;
|
|
14805
|
+
updatedAt?: string;
|
|
14806
|
+
expiresAt?: string;
|
|
14807
|
+
artifactId?: string;
|
|
14808
|
+
publisher?: string;
|
|
14809
|
+
scope?: "artifact" | "publisher" | "harness" | "global";
|
|
14810
|
+
source?: "manual" | "team-policy";
|
|
14811
|
+
harness?: string;
|
|
14812
|
+
exceptionId?: string;
|
|
14813
|
+
};
|
|
14814
|
+
trustMatch?: {
|
|
14815
|
+
recommendation?: "monitor" | "review" | "block";
|
|
14816
|
+
trustScore?: number;
|
|
14817
|
+
artifactType?: "skill" | "plugin";
|
|
14818
|
+
href?: string;
|
|
14819
|
+
ecosystem?: string;
|
|
14820
|
+
safetyScore?: number;
|
|
14821
|
+
verified?: boolean;
|
|
14822
|
+
artifactId?: string;
|
|
14823
|
+
artifactName?: string;
|
|
14824
|
+
artifactSlug?: string;
|
|
14825
|
+
};
|
|
13369
14826
|
}>;
|
|
13370
14827
|
declare const guardTeamPolicyAuditItemSchema: z.ZodObject<{
|
|
13371
14828
|
changedAt: z.ZodString;
|
|
@@ -13387,6 +14844,8 @@ declare const guardTeamPolicyPackSchema: z.ZodObject<{
|
|
|
13387
14844
|
name: z.ZodString;
|
|
13388
14845
|
sharedHarnessDefaults: z.ZodRecord<z.ZodString, z.ZodEnum<["observe", "prompt", "enforce"]>>;
|
|
13389
14846
|
allowedPublishers: z.ZodArray<z.ZodString, "many">;
|
|
14847
|
+
blockedPublishers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
14848
|
+
blockedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
13390
14849
|
blockedArtifacts: z.ZodArray<z.ZodString, "many">;
|
|
13391
14850
|
alertChannel: z.ZodEnum<["email", "slack", "teams", "webhook"]>;
|
|
13392
14851
|
updatedAt: z.ZodString;
|
|
@@ -13409,9 +14868,11 @@ declare const guardTeamPolicyPackSchema: z.ZodObject<{
|
|
|
13409
14868
|
}, "strip", z.ZodTypeAny, {
|
|
13410
14869
|
name?: string;
|
|
13411
14870
|
updatedAt?: string;
|
|
13412
|
-
blockedArtifacts?: string[];
|
|
13413
14871
|
sharedHarnessDefaults?: Record<string, "observe" | "prompt" | "enforce">;
|
|
13414
14872
|
allowedPublishers?: string[];
|
|
14873
|
+
blockedPublishers?: string[];
|
|
14874
|
+
blockedDomains?: string[];
|
|
14875
|
+
blockedArtifacts?: string[];
|
|
13415
14876
|
alertChannel?: "email" | "slack" | "teams" | "webhook";
|
|
13416
14877
|
auditTrail?: {
|
|
13417
14878
|
summary?: string;
|
|
@@ -13422,9 +14883,11 @@ declare const guardTeamPolicyPackSchema: z.ZodObject<{
|
|
|
13422
14883
|
}, {
|
|
13423
14884
|
name?: string;
|
|
13424
14885
|
updatedAt?: string;
|
|
13425
|
-
blockedArtifacts?: string[];
|
|
13426
14886
|
sharedHarnessDefaults?: Record<string, "observe" | "prompt" | "enforce">;
|
|
13427
14887
|
allowedPublishers?: string[];
|
|
14888
|
+
blockedPublishers?: string[];
|
|
14889
|
+
blockedDomains?: string[];
|
|
14890
|
+
blockedArtifacts?: string[];
|
|
13428
14891
|
alertChannel?: "email" | "slack" | "teams" | "webhook";
|
|
13429
14892
|
auditTrail?: {
|
|
13430
14893
|
summary?: string;
|
|
@@ -16968,22 +18431,22 @@ declare const skillDeprecationsResponseSchema: z.ZodObject<{
|
|
|
16968
18431
|
declare const skillSecurityBreakdownResponseSchema: z.ZodObject<{
|
|
16969
18432
|
jobId: z.ZodString;
|
|
16970
18433
|
score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
16971
|
-
findings: z.ZodOptional<z.ZodArray<z.
|
|
16972
|
-
summary: z.ZodOptional<z.
|
|
18434
|
+
findings: z.ZodOptional<z.ZodArray<z.ZodType<JsonValue$1, z.ZodTypeDef, JsonValue$1>, "many">>;
|
|
18435
|
+
summary: z.ZodOptional<z.ZodType<JsonValue$1, z.ZodTypeDef, JsonValue$1>>;
|
|
16973
18436
|
generatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
16974
18437
|
scannerVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
16975
18438
|
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
16976
18439
|
jobId: z.ZodString;
|
|
16977
18440
|
score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
16978
|
-
findings: z.ZodOptional<z.ZodArray<z.
|
|
16979
|
-
summary: z.ZodOptional<z.
|
|
18441
|
+
findings: z.ZodOptional<z.ZodArray<z.ZodType<JsonValue$1, z.ZodTypeDef, JsonValue$1>, "many">>;
|
|
18442
|
+
summary: z.ZodOptional<z.ZodType<JsonValue$1, z.ZodTypeDef, JsonValue$1>>;
|
|
16980
18443
|
generatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
16981
18444
|
scannerVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
16982
18445
|
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
16983
18446
|
jobId: z.ZodString;
|
|
16984
18447
|
score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
16985
|
-
findings: z.ZodOptional<z.ZodArray<z.
|
|
16986
|
-
summary: z.ZodOptional<z.
|
|
18448
|
+
findings: z.ZodOptional<z.ZodArray<z.ZodType<JsonValue$1, z.ZodTypeDef, JsonValue$1>, "many">>;
|
|
18449
|
+
summary: z.ZodOptional<z.ZodType<JsonValue$1, z.ZodTypeDef, JsonValue$1>>;
|
|
16987
18450
|
generatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
16988
18451
|
scannerVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
16989
18452
|
}, z.ZodTypeAny, "passthrough">>;
|
|
@@ -36339,12 +37802,20 @@ interface AutoTopUpOptions {
|
|
|
36339
37802
|
interface HistoryAutoTopUpOptions extends AutoTopUpOptions {
|
|
36340
37803
|
hbarAmount?: number;
|
|
36341
37804
|
}
|
|
37805
|
+
type GuardContractVersion = 1;
|
|
37806
|
+
declare const GUARD_CANONICAL_PATH_PREFIX: "/api/guard";
|
|
37807
|
+
declare const GUARD_COMPAT_PATH_PREFIX: "/guard";
|
|
36342
37808
|
type GuardPlanId = z.infer<typeof guardPlanIdSchema>;
|
|
36343
37809
|
type GuardPrincipal = z.infer<typeof guardPrincipalSchema>;
|
|
36344
37810
|
type GuardEntitlements = z.infer<typeof guardEntitlementsSchema>;
|
|
36345
37811
|
type GuardBucketBalance = z.infer<typeof guardBucketBalanceSchema>;
|
|
36346
37812
|
type GuardSessionResponse = z.infer<typeof guardSessionResponseSchema>;
|
|
36347
37813
|
type GuardBalanceResponse = z.infer<typeof guardBalanceResponseSchema>;
|
|
37814
|
+
type GuardFeedItem = z.infer<typeof guardFeedItemSchema>;
|
|
37815
|
+
type GuardFeedSummary = z.infer<typeof guardFeedSummarySchema>;
|
|
37816
|
+
type GuardFeedResponse = z.infer<typeof guardFeedResponseSchema>;
|
|
37817
|
+
type GuardOverviewResponse = z.infer<typeof guardOverviewResponseSchema>;
|
|
37818
|
+
type GuardPolicy = z.infer<typeof guardPolicySchema>;
|
|
36348
37819
|
type GuardTrustMatch = z.infer<typeof guardTrustMatchSchema>;
|
|
36349
37820
|
type GuardTrustByHashResponse = z.infer<typeof guardTrustByHashResponseSchema>;
|
|
36350
37821
|
interface GuardTrustResolveQuery {
|
|
@@ -36384,6 +37855,27 @@ interface GuardAlertPreferencesUpdate {
|
|
|
36384
37855
|
}
|
|
36385
37856
|
type GuardWatchlistItem = z.infer<typeof guardWatchlistItemSchema>;
|
|
36386
37857
|
type GuardWatchlistResponse = z.infer<typeof guardWatchlistResponseSchema>;
|
|
37858
|
+
type GuardWatchlistLookupResponse = z.infer<typeof guardWatchlistLookupResponseSchema>;
|
|
37859
|
+
type GuardPainSignal = z.infer<typeof guardPainSignalSchema>;
|
|
37860
|
+
type GuardPainSignalAggregate = z.infer<typeof guardPainSignalAggregateSchema>;
|
|
37861
|
+
type GuardPainSignalListResponse = z.infer<typeof guardPainSignalListResponseSchema>;
|
|
37862
|
+
type GuardPainSignalAggregateResponse = z.infer<typeof guardPainSignalAggregateResponseSchema>;
|
|
37863
|
+
type GuardPreflightEvidence = z.infer<typeof guardPreflightEvidenceSchema>;
|
|
37864
|
+
type GuardPreflightRequest = z.infer<typeof guardPreflightRequestSchema>;
|
|
37865
|
+
type GuardPreflightVerdictResponse = z.infer<typeof guardPreflightVerdictResponseSchema>;
|
|
37866
|
+
interface GuardPainSignalIngestItem {
|
|
37867
|
+
signalId: string;
|
|
37868
|
+
signalName: string;
|
|
37869
|
+
artifactId: string;
|
|
37870
|
+
artifactName: string;
|
|
37871
|
+
artifactType: GuardInventoryArtifact['artifactType'];
|
|
37872
|
+
harness: string;
|
|
37873
|
+
latestSummary: string;
|
|
37874
|
+
occurredAt: string;
|
|
37875
|
+
count?: number;
|
|
37876
|
+
source?: 'scanner';
|
|
37877
|
+
publisher?: string;
|
|
37878
|
+
}
|
|
36387
37879
|
interface GuardWatchlistUpsert {
|
|
36388
37880
|
artifactId: string;
|
|
36389
37881
|
artifactName: string;
|
|
@@ -36402,6 +37894,8 @@ interface GuardTeamPolicyPackUpdate {
|
|
|
36402
37894
|
name?: string;
|
|
36403
37895
|
sharedHarnessDefaults?: GuardTeamPolicyPack['sharedHarnessDefaults'];
|
|
36404
37896
|
allowedPublishers?: string[];
|
|
37897
|
+
blockedPublishers?: string[];
|
|
37898
|
+
blockedDomains?: string[];
|
|
36405
37899
|
blockedArtifacts?: string[];
|
|
36406
37900
|
alertChannel?: GuardTeamPolicyPack['alertChannel'];
|
|
36407
37901
|
}
|
|
@@ -37084,8 +38578,11 @@ declare class RegistryBrokerClient {
|
|
|
37084
38578
|
getDefaultHeaders(): Record<string, string>;
|
|
37085
38579
|
encryptionReady(): Promise<void>;
|
|
37086
38580
|
buildUrl(path: string): string;
|
|
38581
|
+
private buildRequestInit;
|
|
37087
38582
|
request(path: string, config: RequestConfig): Promise<Response>;
|
|
38583
|
+
requestAbsolute(url: string, config: RequestConfig): Promise<Response>;
|
|
37088
38584
|
requestJson<T extends JsonValue = JsonValue>(path: string, config: RequestConfig): Promise<T>;
|
|
38585
|
+
requestAbsoluteJson<T extends JsonValue = JsonValue>(url: string, config: RequestConfig): Promise<T>;
|
|
37089
38586
|
getAgentFeedback(uaid: string, options?: AgentFeedbackQuery): Promise<AgentFeedbackResponse>;
|
|
37090
38587
|
listAgentFeedbackIndex(options?: {
|
|
37091
38588
|
page?: number;
|
|
@@ -37216,25 +38713,39 @@ declare class RegistryBrokerClient {
|
|
|
37216
38713
|
getGuardSession(): Promise<GuardSessionResponse>;
|
|
37217
38714
|
getGuardEntitlements(): Promise<GuardSessionResponse>;
|
|
37218
38715
|
getGuardBillingBalance(): Promise<GuardBalanceResponse>;
|
|
38716
|
+
getGuardFeed(limit?: number): Promise<GuardFeedResponse>;
|
|
38717
|
+
getGuardOverview(): Promise<GuardOverviewResponse>;
|
|
37219
38718
|
getGuardTrustByHash(sha256: string): Promise<GuardTrustByHashResponse>;
|
|
37220
38719
|
resolveGuardTrust(query: GuardTrustResolveQuery): Promise<GuardTrustResolveResponse>;
|
|
37221
38720
|
getGuardRevocations(): Promise<GuardRevocationResponse>;
|
|
38721
|
+
fetchGuardAdvisories(): Promise<GuardRevocationResponse>;
|
|
38722
|
+
fetchGuardPolicy(): Promise<GuardPolicy>;
|
|
37222
38723
|
getGuardInventory(): Promise<GuardInventoryResponse>;
|
|
37223
38724
|
getGuardReceiptHistory(): Promise<GuardReceiptHistoryResponse>;
|
|
37224
38725
|
getGuardArtifactTimeline(artifactId: string): Promise<GuardArtifactTimelineResponse>;
|
|
37225
38726
|
getGuardInventoryDiff(): Promise<GuardInventoryDiffResponse>;
|
|
37226
38727
|
exportGuardAbom(): Promise<GuardAbomResponse>;
|
|
38728
|
+
exportGuardArtifactAbom(artifactId: string): Promise<GuardAbomResponse>;
|
|
37227
38729
|
exportGuardReceipts(): Promise<GuardReceiptExportResponse>;
|
|
37228
38730
|
getGuardDevices(): Promise<GuardDeviceListResponse>;
|
|
37229
38731
|
getGuardAlertPreferences(): Promise<GuardAlertPreferences>;
|
|
37230
38732
|
updateGuardAlertPreferences(payload: GuardAlertPreferencesUpdate): Promise<GuardAlertPreferences>;
|
|
37231
38733
|
getGuardExceptions(): Promise<GuardExceptionListResponse>;
|
|
37232
38734
|
getGuardWatchlist(): Promise<GuardWatchlistResponse>;
|
|
38735
|
+
lookupGuardWatchlist(payload: GuardPreflightRequest): Promise<GuardWatchlistLookupResponse>;
|
|
38736
|
+
getGuardPainSignals(): Promise<GuardPainSignalListResponse>;
|
|
38737
|
+
getGuardAggregatedPainSignals(): Promise<GuardPainSignalAggregateResponse>;
|
|
38738
|
+
getGuardPreInstallVerdict(payload: GuardPreflightRequest): Promise<GuardPreflightVerdictResponse>;
|
|
38739
|
+
getGuardPreExecutionVerdict(payload: GuardPreflightRequest): Promise<GuardPreflightVerdictResponse>;
|
|
37233
38740
|
addGuardWatchlistItem(payload: GuardWatchlistUpsert): Promise<GuardWatchlistResponse>;
|
|
37234
38741
|
removeGuardWatchlistItem(artifactId: string): Promise<GuardWatchlistResponse>;
|
|
37235
38742
|
addGuardException(payload: GuardExceptionUpsert): Promise<GuardExceptionListResponse>;
|
|
38743
|
+
requestGuardException(payload: GuardExceptionUpsert): Promise<GuardExceptionListResponse>;
|
|
37236
38744
|
removeGuardException(exceptionId: string): Promise<GuardExceptionListResponse>;
|
|
38745
|
+
ingestGuardPainSignals(items: GuardPainSignalIngestItem[]): Promise<GuardPainSignalListResponse>;
|
|
37237
38746
|
syncGuardReceipts(payload: GuardReceiptSyncPayload): Promise<GuardReceiptSyncResponse>;
|
|
38747
|
+
syncGuardInventory(payload: GuardReceiptSyncPayload): Promise<GuardReceiptSyncResponse>;
|
|
38748
|
+
submitGuardReceipts(payload: GuardReceiptSyncPayload): Promise<GuardReceiptSyncResponse>;
|
|
37238
38749
|
getGuardTeamPolicyPack(): Promise<GuardTeamPolicyPack>;
|
|
37239
38750
|
updateGuardTeamPolicyPack(payload: GuardTeamPolicyPackUpdate): Promise<GuardTeamPolicyPack>;
|
|
37240
38751
|
createHbarPurchaseIntent(payload: HbarPurchaseIntentRequest): Promise<HbarPurchaseIntentResponse>;
|
|
@@ -37388,4 +38899,4 @@ declare const buildJobStatusMessage: (input: {
|
|
|
37388
38899
|
jobId: number;
|
|
37389
38900
|
}) => string;
|
|
37390
38901
|
|
|
37391
|
-
export { type AcceptConversationOptions, type AcceptEncryptedChatSessionOptions, type AdapterDetailsResponse, type AdapterRegistryAdaptersResponse, type AdapterRegistryCategoriesResponse, type AdapterRegistryCategory, type AdapterRegistryCreateCategoryResponse, type AdapterRegistrySubmissionStatusResponse, type AdapterRegistrySubmitAdapterAcceptedResponse, type AdapterRegistrySubmitAdapterResponse, type AdaptersResponse, type AdditionalRegistryCatalogResponse, type AdditionalRegistryDescriptor, type AdditionalRegistryNetworkDescriptor, type AgentAuthConfig, type AgentAuthType, type AgentFeedbackEligibilityRequest, type AgentFeedbackEligibilityResponse, type AgentFeedbackEntriesIndexResponse, type AgentFeedbackIndexResponse, type AgentFeedbackQuery, type AgentFeedbackResponse, type AgentFeedbackSubmissionRequest, type AgentFeedbackSubmissionResponse, type AgentProfile, type AgentRegistrationRequest, type AgentRegistrationRequestMetadata, type AgentSearchHit, type AutoRegisterEncryptionKeyOptions, type AutoTopUpOptions, type CanonicalLedgerNetwork, type ChatConversationHandle, type ChatHistoryCompactionResponse, type ChatHistoryEntry, type ChatHistoryFetchOptions, type ChatHistorySnapshotResponse, type ChatHistorySnapshotWithDecryptedEntries, type CipherEnvelope, type CipherEnvelopeRecipient, type ClientEncryptionOptions, type CompactHistoryRequestPayload, type ConversationEncryptionOptions, type ConversationMode, type CreateAdapterRegistryCategoryRequest, type CreateSessionRequestPayload, type CreateSessionResponse, type CreditBalanceResponse, type CreditProviderSummary, type CreditProvidersResponse, type CreditPurchaseResponse, type DashboardStatsResponse, type DecryptCipherEnvelopeOptions, type DecryptedHistoryEntry, type DelegationOpportunity, type DelegationPlanCandidate, type DelegationPlanFilter, type DelegationPlanRequest, type DelegationPlanResponse, type DelegationWorkspaceContext, type DeriveSharedSecretOptions, type DetectProtocolResponse, type EncryptCipherEnvelopeOptions, type EncryptedChatSendOptions, type EncryptedChatSessionHandle, type EncryptionHandshakeRecord, type EncryptionHandshakeResponse, type EncryptionHandshakeSubmissionPayload, type EnsureAgentKeyOptions, type EphemeralKeyPair, type GenerateEncryptionKeyPairOptions, type GuardAbomResponse, type GuardAbomSummary, type GuardAlertPreferences, type GuardAlertPreferencesUpdate, type GuardArtifactTimelineResponse, type GuardBalanceResponse, type GuardBucketBalance, type GuardDevice, type GuardDeviceListResponse, type GuardEntitlements, type GuardExceptionItem, type GuardExceptionListResponse, type GuardExceptionScope, type GuardExceptionSource, type GuardExceptionUpsert, type GuardExportSignature, type GuardHistoryArtifact, type GuardInventoryArtifact, type GuardInventoryDiffEntry, type GuardInventoryDiffResponse, type GuardInventoryResponse, type GuardPlanId, type GuardPrincipal, type GuardReceipt, type GuardReceiptExportResponse, type GuardReceiptExportSummary, type GuardReceiptHistoryResponse, type GuardReceiptSyncPayload, type GuardReceiptSyncResponse, type GuardRevocationResponse, type GuardSessionResponse, type GuardTeamPolicyAuditItem, type GuardTeamPolicyPack, type GuardTeamPolicyPackUpdate, type GuardTimelineEvent, type GuardTrustByHashResponse, type GuardTrustMatch, type GuardTrustResolveQuery, type GuardTrustResolveResponse, type GuardWatchlistItem, type GuardWatchlistResponse, type GuardWatchlistUpsert, HOL_CHAT_PROTOCOL_ID, type HbarPurchaseIntentRequest, type HbarPurchaseIntentResponse, type HistoryAutoTopUpOptions, type HolChatOp, type HolChatOpBase, type HolChatOpName, type InitializeAgentClientOptions, type InitializedAgentClient, type JsonObject, type JsonPrimitive, type JsonValue, type LedgerAuthenticationLogger, type LedgerAuthenticationOptions, type LedgerAuthenticationSignerResult, type LedgerChallengeRequest, type LedgerChallengeResponse, type LedgerCredentialAuthOptions, type LedgerVerifyRequest, type LedgerVerifyResponse, type MetricsSummaryResponse, type MoltbookOwnerRegistrationUpdateRequest, type MoltbookOwnerRegistrationUpdateResponse, type PopularSearchesResponse, type PrivateKeySignerOptions, type ProtocolDetectionMessage, type ProtocolsResponse, type RecipientIdentity, type RegisterAgentOptions, type RegisterAgentPartialResponse, type RegisterAgentPendingResponse, type RegisterAgentQuoteResponse, type RegisterAgentResponse, type RegisterAgentSuccessResponse, type RegisterEncryptionKeyPayload, type RegisterEncryptionKeyResponse, type RegisterStatusResponse, type RegistrationProgressAdditionalEntry, type RegistrationProgressRecord, type RegistrationProgressResponse, type RegistrationProgressWaitOptions, type RegistriesResponse, RegistryBrokerClient, type RegistryBrokerClientOptions, RegistryBrokerError, RegistryBrokerParseError, type RegistrySearchByNamespaceResponse, type RegistryStatsResponse, type ResolvedAgentResponse, type SearchFacetsResponse, type SearchParams, type SearchResult, type SearchStatusResponse, type SendMessageBasePayload, type SendMessageEncryptionOptions, type SendMessageRequestPayload, type SendMessageResponse, type SessionEncryptionStatusResponse, type SessionEncryptionSummary, type SharedSecretInput, type SkillBadgeMetric, type SkillBadgeQuery, type SkillBadgeResponse, type SkillBadgeStyle, type SkillCatalogChannel, type SkillCatalogItem, type SkillCatalogQueryOptions, type SkillCatalogResponse, type SkillCatalogSortBy, type SkillCatalogVersionSummary, type SkillConversionSignalsResponse, type SkillDeprecationRecord, type SkillDeprecationSetRequest, type SkillDeprecationsResponse, type SkillInstallArtifactDescriptor, type SkillInstallBadgeDescriptor, type SkillInstallCopyTelemetryRequest, type SkillInstallCopyTelemetryResponse, type SkillInstallResolverDescriptor, type SkillInstallResponse, type SkillInstallShareDescriptor, type SkillInstallSnippetSet, type SkillListOptions, type SkillPreviewByRepoRequest, type SkillPreviewLookupRequest, type SkillPreviewLookupResponse, type SkillPreviewRecord, type SkillPreviewReport, type SkillPreviewSuggestedNextStep, type SkillQuotePreviewRange, type SkillQuotePreviewRequest, type SkillQuotePreviewResponse, type SkillRecommendedVersionResponse, type SkillRecommendedVersionSetRequest, type SkillRegistryCategoriesResponse, type SkillRegistryConfigResponse, type SkillRegistryFileDescriptor, type SkillRegistryFileInput, type SkillRegistryFileRole, type SkillRegistryJobStatusResponse, type SkillRegistryListResponse, type SkillRegistryMineResponse, type SkillRegistryMyListResponse, type SkillRegistryOwnershipResponse, type SkillRegistryPublishRequest, type SkillRegistryPublishResponse, type SkillRegistryPublishSummary, type SkillRegistryQuoteRequest, type SkillRegistryQuoteResponse, type SkillRegistryTagsResponse, type SkillRegistryVersionsResponse, type SkillRegistryVoteRequest, type SkillRegistryVoteStatusResponse, type SkillResolverManifestResponse, type SkillSecurityBreakdownRequest, type SkillSecurityBreakdownResponse, type SkillStatusChecks, type SkillStatusNextStep, type SkillStatusPreviewMetadata, type SkillStatusProvenanceSignals, type SkillStatusRequest, type SkillStatusResponse, type SkillStatusVerificationSignals, type SkillTrustTier, type SkillVerificationDomainProofChallengeRequest, type SkillVerificationDomainProofChallengeResponse, type SkillVerificationDomainProofVerifyRequest, type SkillVerificationDomainProofVerifyResponse, type SkillVerificationRequest, type SkillVerificationRequestCreateRequest, type SkillVerificationRequestCreateResponse, type SkillVerificationStatusResponse, type SkillVerificationTier, type StartChatBaseOptions, type StartChatOptions, type StartConversationOptions, type StartEncryptedChatSessionOptions, type SubmitAdapterRegistryAdapterRequest, type UaidConnectionStatus, type UaidValidationResponse, type UploadSkillPreviewFromGithubOidcRequest, type VectorSearchFilter, type VectorSearchRequest, type VectorSearchResponse, type VerificationChallengeDetailsResponse, type VerificationChallengeResponse, type VerificationDnsStatusQuery, type VerificationDnsStatusResponse, type VerificationDnsVerifyRequest, type VerificationOwnershipResponse, type VerificationStatusResponse, type VerificationVerifyResponse, type VerificationVerifySenderResponse, type WebsocketStatsResponse, type X402CreditPurchaseResponse, type X402MinimumsResponse, buildJobStatusMessage, buildPaymentApproveMessage, buildPaymentDeclineMessage, canonicalizeLedgerNetwork, closeUaidConnection, createPrivateKeySigner, createPrivateKeySignerAsync, dashboardStats, getRegistrationProgress, getRegistrationQuote, getUaidConnectionStatus, isHolChatOp, isPartialRegisterAgentResponse, isPendingRegisterAgentResponse, isSuccessRegisterAgentResponse, parseHolChatOps, registerAgent, resolveUaid, updateAgent, validateUaid, waitForRegistrationCompletion };
|
|
38902
|
+
export { type AcceptConversationOptions, type AcceptEncryptedChatSessionOptions, type AdapterDetailsResponse, type AdapterRegistryAdaptersResponse, type AdapterRegistryCategoriesResponse, type AdapterRegistryCategory, type AdapterRegistryCreateCategoryResponse, type AdapterRegistrySubmissionStatusResponse, type AdapterRegistrySubmitAdapterAcceptedResponse, type AdapterRegistrySubmitAdapterResponse, type AdaptersResponse, type AdditionalRegistryCatalogResponse, type AdditionalRegistryDescriptor, type AdditionalRegistryNetworkDescriptor, type AgentAuthConfig, type AgentAuthType, type AgentFeedbackEligibilityRequest, type AgentFeedbackEligibilityResponse, type AgentFeedbackEntriesIndexResponse, type AgentFeedbackIndexResponse, type AgentFeedbackQuery, type AgentFeedbackResponse, type AgentFeedbackSubmissionRequest, type AgentFeedbackSubmissionResponse, type AgentProfile, type AgentRegistrationRequest, type AgentRegistrationRequestMetadata, type AgentSearchHit, type AutoRegisterEncryptionKeyOptions, type AutoTopUpOptions, type CanonicalLedgerNetwork, type ChatConversationHandle, type ChatHistoryCompactionResponse, type ChatHistoryEntry, type ChatHistoryFetchOptions, type ChatHistorySnapshotResponse, type ChatHistorySnapshotWithDecryptedEntries, type CipherEnvelope, type CipherEnvelopeRecipient, type ClientEncryptionOptions, type CompactHistoryRequestPayload, type ConversationEncryptionOptions, type ConversationMode, type CreateAdapterRegistryCategoryRequest, type CreateSessionRequestPayload, type CreateSessionResponse, type CreditBalanceResponse, type CreditProviderSummary, type CreditProvidersResponse, type CreditPurchaseResponse, type DashboardStatsResponse, type DecryptCipherEnvelopeOptions, type DecryptedHistoryEntry, type DelegationOpportunity, type DelegationPlanCandidate, type DelegationPlanFilter, type DelegationPlanRequest, type DelegationPlanResponse, type DelegationWorkspaceContext, type DeriveSharedSecretOptions, type DetectProtocolResponse, type EncryptCipherEnvelopeOptions, type EncryptedChatSendOptions, type EncryptedChatSessionHandle, type EncryptionHandshakeRecord, type EncryptionHandshakeResponse, type EncryptionHandshakeSubmissionPayload, type EnsureAgentKeyOptions, type EphemeralKeyPair, GUARD_CANONICAL_PATH_PREFIX, GUARD_COMPAT_PATH_PREFIX, type GenerateEncryptionKeyPairOptions, type GuardAbomResponse, type GuardAbomSummary, type GuardAlertPreferences, type GuardAlertPreferencesUpdate, type GuardArtifactTimelineResponse, type GuardBalanceResponse, type GuardBucketBalance, type GuardContractVersion, type GuardDevice, type GuardDeviceListResponse, type GuardEntitlements, type GuardExceptionItem, type GuardExceptionListResponse, type GuardExceptionScope, type GuardExceptionSource, type GuardExceptionUpsert, type GuardExportSignature, type GuardFeedItem, type GuardFeedResponse, type GuardFeedSummary, type GuardHistoryArtifact, type GuardInventoryArtifact, type GuardInventoryDiffEntry, type GuardInventoryDiffResponse, type GuardInventoryResponse, type GuardOverviewResponse, type GuardPainSignal, type GuardPainSignalAggregate, type GuardPainSignalAggregateResponse, type GuardPainSignalIngestItem, type GuardPainSignalListResponse, type GuardPlanId, type GuardPolicy, type GuardPreflightEvidence, type GuardPreflightRequest, type GuardPreflightVerdictResponse, type GuardPrincipal, type GuardReceipt, type GuardReceiptExportResponse, type GuardReceiptExportSummary, type GuardReceiptHistoryResponse, type GuardReceiptSyncPayload, type GuardReceiptSyncResponse, type GuardRevocationResponse, type GuardSessionResponse, type GuardTeamPolicyAuditItem, type GuardTeamPolicyPack, type GuardTeamPolicyPackUpdate, type GuardTimelineEvent, type GuardTrustByHashResponse, type GuardTrustMatch, type GuardTrustResolveQuery, type GuardTrustResolveResponse, type GuardWatchlistItem, type GuardWatchlistLookupResponse, type GuardWatchlistResponse, type GuardWatchlistUpsert, HOL_CHAT_PROTOCOL_ID, type HbarPurchaseIntentRequest, type HbarPurchaseIntentResponse, type HistoryAutoTopUpOptions, type HolChatOp, type HolChatOpBase, type HolChatOpName, type InitializeAgentClientOptions, type InitializedAgentClient, type JsonObject, type JsonPrimitive, type JsonValue, type LedgerAuthenticationLogger, type LedgerAuthenticationOptions, type LedgerAuthenticationSignerResult, type LedgerChallengeRequest, type LedgerChallengeResponse, type LedgerCredentialAuthOptions, type LedgerVerifyRequest, type LedgerVerifyResponse, type MetricsSummaryResponse, type MoltbookOwnerRegistrationUpdateRequest, type MoltbookOwnerRegistrationUpdateResponse, type PopularSearchesResponse, type PrivateKeySignerOptions, type ProtocolDetectionMessage, type ProtocolsResponse, type RecipientIdentity, type RegisterAgentOptions, type RegisterAgentPartialResponse, type RegisterAgentPendingResponse, type RegisterAgentQuoteResponse, type RegisterAgentResponse, type RegisterAgentSuccessResponse, type RegisterEncryptionKeyPayload, type RegisterEncryptionKeyResponse, type RegisterStatusResponse, type RegistrationProgressAdditionalEntry, type RegistrationProgressRecord, type RegistrationProgressResponse, type RegistrationProgressWaitOptions, type RegistriesResponse, RegistryBrokerClient, type RegistryBrokerClientOptions, RegistryBrokerError, RegistryBrokerParseError, type RegistrySearchByNamespaceResponse, type RegistryStatsResponse, type ResolvedAgentResponse, type SearchFacetsResponse, type SearchParams, type SearchResult, type SearchStatusResponse, type SendMessageBasePayload, type SendMessageEncryptionOptions, type SendMessageRequestPayload, type SendMessageResponse, type SessionEncryptionStatusResponse, type SessionEncryptionSummary, type SharedSecretInput, type SkillBadgeMetric, type SkillBadgeQuery, type SkillBadgeResponse, type SkillBadgeStyle, type SkillCatalogChannel, type SkillCatalogItem, type SkillCatalogQueryOptions, type SkillCatalogResponse, type SkillCatalogSortBy, type SkillCatalogVersionSummary, type SkillConversionSignalsResponse, type SkillDeprecationRecord, type SkillDeprecationSetRequest, type SkillDeprecationsResponse, type SkillInstallArtifactDescriptor, type SkillInstallBadgeDescriptor, type SkillInstallCopyTelemetryRequest, type SkillInstallCopyTelemetryResponse, type SkillInstallResolverDescriptor, type SkillInstallResponse, type SkillInstallShareDescriptor, type SkillInstallSnippetSet, type SkillListOptions, type SkillPreviewByRepoRequest, type SkillPreviewLookupRequest, type SkillPreviewLookupResponse, type SkillPreviewRecord, type SkillPreviewReport, type SkillPreviewSuggestedNextStep, type SkillQuotePreviewRange, type SkillQuotePreviewRequest, type SkillQuotePreviewResponse, type SkillRecommendedVersionResponse, type SkillRecommendedVersionSetRequest, type SkillRegistryCategoriesResponse, type SkillRegistryConfigResponse, type SkillRegistryFileDescriptor, type SkillRegistryFileInput, type SkillRegistryFileRole, type SkillRegistryJobStatusResponse, type SkillRegistryListResponse, type SkillRegistryMineResponse, type SkillRegistryMyListResponse, type SkillRegistryOwnershipResponse, type SkillRegistryPublishRequest, type SkillRegistryPublishResponse, type SkillRegistryPublishSummary, type SkillRegistryQuoteRequest, type SkillRegistryQuoteResponse, type SkillRegistryTagsResponse, type SkillRegistryVersionsResponse, type SkillRegistryVoteRequest, type SkillRegistryVoteStatusResponse, type SkillResolverManifestResponse, type SkillSecurityBreakdownRequest, type SkillSecurityBreakdownResponse, type SkillStatusChecks, type SkillStatusNextStep, type SkillStatusPreviewMetadata, type SkillStatusProvenanceSignals, type SkillStatusRequest, type SkillStatusResponse, type SkillStatusVerificationSignals, type SkillTrustTier, type SkillVerificationDomainProofChallengeRequest, type SkillVerificationDomainProofChallengeResponse, type SkillVerificationDomainProofVerifyRequest, type SkillVerificationDomainProofVerifyResponse, type SkillVerificationRequest, type SkillVerificationRequestCreateRequest, type SkillVerificationRequestCreateResponse, type SkillVerificationStatusResponse, type SkillVerificationTier, type StartChatBaseOptions, type StartChatOptions, type StartConversationOptions, type StartEncryptedChatSessionOptions, type SubmitAdapterRegistryAdapterRequest, type UaidConnectionStatus, type UaidValidationResponse, type UploadSkillPreviewFromGithubOidcRequest, type VectorSearchFilter, type VectorSearchRequest, type VectorSearchResponse, type VerificationChallengeDetailsResponse, type VerificationChallengeResponse, type VerificationDnsStatusQuery, type VerificationDnsStatusResponse, type VerificationDnsVerifyRequest, type VerificationOwnershipResponse, type VerificationStatusResponse, type VerificationVerifyResponse, type VerificationVerifySenderResponse, type WebsocketStatsResponse, type X402CreditPurchaseResponse, type X402MinimumsResponse, buildJobStatusMessage, buildPaymentApproveMessage, buildPaymentDeclineMessage, canonicalizeLedgerNetwork, closeUaidConnection, createPrivateKeySigner, createPrivateKeySignerAsync, dashboardStats, getRegistrationProgress, getRegistrationQuote, getUaidConnectionStatus, isHolChatOp, isPartialRegisterAgentResponse, isPendingRegisterAgentResponse, isSuccessRegisterAgentResponse, parseHolChatOps, registerAgent, resolveUaid, updateAgent, validateUaid, waitForRegistrationCompletion };
|