@crawlcheck/sdk 0.0.0-stage → 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +58 -2
- package/dist/gen/openapi.d.ts +3233 -0
- package/dist/gen/openapi.js +5 -0
- package/dist/index.d.ts +148 -0
- package/dist/index.js +128 -0
- package/dist/verify.d.ts +27 -0
- package/dist/verify.js +345 -0
- package/package.json +34 -3
- package/test/sdk.test.js +45 -0
|
@@ -0,0 +1,3233 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* This file was auto-generated by openapi-typescript.
|
|
3
|
+
* Do not make direct changes to the file.
|
|
4
|
+
*/
|
|
5
|
+
export interface paths {
|
|
6
|
+
"/api/scan": {
|
|
7
|
+
parameters: {
|
|
8
|
+
query?: never;
|
|
9
|
+
header?: never;
|
|
10
|
+
path?: never;
|
|
11
|
+
cookie?: never;
|
|
12
|
+
};
|
|
13
|
+
get?: never;
|
|
14
|
+
put?: never;
|
|
15
|
+
/** Scan a domain as several crawler identities and return a graded record */
|
|
16
|
+
post: operations["scan"];
|
|
17
|
+
delete?: never;
|
|
18
|
+
options?: never;
|
|
19
|
+
head?: never;
|
|
20
|
+
patch?: never;
|
|
21
|
+
trace?: never;
|
|
22
|
+
};
|
|
23
|
+
"/api/v1/scan": {
|
|
24
|
+
parameters: {
|
|
25
|
+
query?: never;
|
|
26
|
+
header?: never;
|
|
27
|
+
path?: never;
|
|
28
|
+
cookie?: never;
|
|
29
|
+
};
|
|
30
|
+
get?: never;
|
|
31
|
+
put?: never;
|
|
32
|
+
/** Versioned scan: returns PublicReportV1 (stable allowlist, JSON Schema at /api/v1/schema) */
|
|
33
|
+
post: operations["scanDomainV1"];
|
|
34
|
+
delete?: never;
|
|
35
|
+
options?: never;
|
|
36
|
+
head?: never;
|
|
37
|
+
patch?: never;
|
|
38
|
+
trace?: never;
|
|
39
|
+
};
|
|
40
|
+
"/api/v1/machine-record": {
|
|
41
|
+
parameters: {
|
|
42
|
+
query?: never;
|
|
43
|
+
header?: never;
|
|
44
|
+
path?: never;
|
|
45
|
+
cookie?: never;
|
|
46
|
+
};
|
|
47
|
+
/** The unified machine record for one observation: subject, grade, findings (top one in full without a licence), capabilities with verification, evidence roots and verifier links */
|
|
48
|
+
get: operations["getMachineRecordV1"];
|
|
49
|
+
put?: never;
|
|
50
|
+
post?: never;
|
|
51
|
+
delete?: never;
|
|
52
|
+
options?: never;
|
|
53
|
+
head?: never;
|
|
54
|
+
patch?: never;
|
|
55
|
+
trace?: never;
|
|
56
|
+
};
|
|
57
|
+
"/api/fix/cache": {
|
|
58
|
+
parameters: {
|
|
59
|
+
query?: never;
|
|
60
|
+
header?: never;
|
|
61
|
+
path?: never;
|
|
62
|
+
cookie?: never;
|
|
63
|
+
};
|
|
64
|
+
/** STALE_CACHE_SERVED fix plan: the homepage fetched now, its Age, the cache layers in purge order (innermost first), the declared HTML lifetime, a fresh-read comparison, and whether a purge clears the finding and keeps it cleared */
|
|
65
|
+
get: operations["fixStaleCache"];
|
|
66
|
+
put?: never;
|
|
67
|
+
post?: never;
|
|
68
|
+
delete?: never;
|
|
69
|
+
options?: never;
|
|
70
|
+
head?: never;
|
|
71
|
+
patch?: never;
|
|
72
|
+
trace?: never;
|
|
73
|
+
};
|
|
74
|
+
"/api/fix/chain": {
|
|
75
|
+
parameters: {
|
|
76
|
+
query?: never;
|
|
77
|
+
header?: never;
|
|
78
|
+
path?: never;
|
|
79
|
+
cookie?: never;
|
|
80
|
+
};
|
|
81
|
+
/** MACHINE_CHAIN_HEAVY fix plan: the files read before the page and the absent-file 404s, measured reductions with the chain size after each, and the step at which the detector stops firing */
|
|
82
|
+
get: operations["fixMachineChain"];
|
|
83
|
+
put?: never;
|
|
84
|
+
post?: never;
|
|
85
|
+
delete?: never;
|
|
86
|
+
options?: never;
|
|
87
|
+
head?: never;
|
|
88
|
+
patch?: never;
|
|
89
|
+
trace?: never;
|
|
90
|
+
};
|
|
91
|
+
"/api/fix/code": {
|
|
92
|
+
parameters: {
|
|
93
|
+
query?: never;
|
|
94
|
+
header?: never;
|
|
95
|
+
path?: never;
|
|
96
|
+
cookie?: never;
|
|
97
|
+
};
|
|
98
|
+
/** PAGE_IS_MOSTLY_CODE fix plan: the measured byte breakdown, ordered steps with the ratio after each, the step at which the detector stops firing, or the markup/text change needed when moving code cannot clear it */
|
|
99
|
+
get: operations["fixMostlyCode"];
|
|
100
|
+
put?: never;
|
|
101
|
+
post?: never;
|
|
102
|
+
delete?: never;
|
|
103
|
+
options?: never;
|
|
104
|
+
head?: never;
|
|
105
|
+
patch?: never;
|
|
106
|
+
trace?: never;
|
|
107
|
+
};
|
|
108
|
+
"/api/corroboration": {
|
|
109
|
+
parameters: {
|
|
110
|
+
query?: never;
|
|
111
|
+
header?: never;
|
|
112
|
+
path?: never;
|
|
113
|
+
cookie?: never;
|
|
114
|
+
};
|
|
115
|
+
/** Each observer's reading of the identity-dependent findings side by side (primary Worker vs the independent second observer), with a corroboration status per finding */
|
|
116
|
+
get: operations["getCorroboration"];
|
|
117
|
+
put?: never;
|
|
118
|
+
post?: never;
|
|
119
|
+
delete?: never;
|
|
120
|
+
options?: never;
|
|
121
|
+
head?: never;
|
|
122
|
+
patch?: never;
|
|
123
|
+
trace?: never;
|
|
124
|
+
};
|
|
125
|
+
"/api/explain": {
|
|
126
|
+
parameters: {
|
|
127
|
+
query?: never;
|
|
128
|
+
header?: never;
|
|
129
|
+
path?: never;
|
|
130
|
+
cookie?: never;
|
|
131
|
+
};
|
|
132
|
+
/** One finding explained: rule and revision, compared fetches, valid time, Merkle proof of the decision in the signed manifest */
|
|
133
|
+
get: operations["explainFinding"];
|
|
134
|
+
put?: never;
|
|
135
|
+
post?: never;
|
|
136
|
+
delete?: never;
|
|
137
|
+
options?: never;
|
|
138
|
+
head?: never;
|
|
139
|
+
patch?: never;
|
|
140
|
+
trace?: never;
|
|
141
|
+
};
|
|
142
|
+
"/api/capabilities": {
|
|
143
|
+
parameters: {
|
|
144
|
+
query?: never;
|
|
145
|
+
header?: never;
|
|
146
|
+
path?: never;
|
|
147
|
+
cookie?: never;
|
|
148
|
+
};
|
|
149
|
+
/** Declared agent capabilities with safety class, verification state and declaration-vs-behaviour mismatches, from the latest scan */
|
|
150
|
+
get: operations["listVerifiedCapabilities"];
|
|
151
|
+
put?: never;
|
|
152
|
+
post?: never;
|
|
153
|
+
delete?: never;
|
|
154
|
+
options?: never;
|
|
155
|
+
head?: never;
|
|
156
|
+
patch?: never;
|
|
157
|
+
trace?: never;
|
|
158
|
+
};
|
|
159
|
+
"/api/v1/reports/{id}": {
|
|
160
|
+
parameters: {
|
|
161
|
+
query?: never;
|
|
162
|
+
header?: never;
|
|
163
|
+
path?: never;
|
|
164
|
+
cookie?: never;
|
|
165
|
+
};
|
|
166
|
+
/** A stored report as PublicReportV1 (licence or read-scoped API key) */
|
|
167
|
+
get: operations["getReportV1"];
|
|
168
|
+
put?: never;
|
|
169
|
+
post?: never;
|
|
170
|
+
delete?: never;
|
|
171
|
+
options?: never;
|
|
172
|
+
head?: never;
|
|
173
|
+
patch?: never;
|
|
174
|
+
trace?: never;
|
|
175
|
+
};
|
|
176
|
+
"/api/locate": {
|
|
177
|
+
parameters: {
|
|
178
|
+
query?: never;
|
|
179
|
+
header?: never;
|
|
180
|
+
path?: never;
|
|
181
|
+
cookie?: never;
|
|
182
|
+
};
|
|
183
|
+
/** Check every source locator in a record against the stored page: each extracted value's UTF-8 byte range is cut from the sealed page bytes (re-hashed first) and compared with the recorded value. With finding=CODE, the same for a finding: the robots.txt lines, the HTML tag served where a file should be, the empty <urlset>, an absence re-checked over the whole stored file, a manifest field */
|
|
184
|
+
get: operations["locateFacts"];
|
|
185
|
+
put?: never;
|
|
186
|
+
post?: never;
|
|
187
|
+
delete?: never;
|
|
188
|
+
options?: never;
|
|
189
|
+
head?: never;
|
|
190
|
+
patch?: never;
|
|
191
|
+
trace?: never;
|
|
192
|
+
};
|
|
193
|
+
"/conformance/index.json": {
|
|
194
|
+
parameters: {
|
|
195
|
+
query?: never;
|
|
196
|
+
header?: never;
|
|
197
|
+
path?: never;
|
|
198
|
+
cookie?: never;
|
|
199
|
+
};
|
|
200
|
+
/** The conformance suite: real bundles and receipts of crawlcheck.io's own scans (valid in three manifest eras, incomplete, unsealed, tampered one field at a time, contradictory, foreign-key) with the exact output a conforming verifier must give for every check, each file's SHA-256, and the runner (/conformance/run.mjs) that checks a verifier against all of them. Public */
|
|
201
|
+
get: operations["conformanceIndex"];
|
|
202
|
+
put?: never;
|
|
203
|
+
post?: never;
|
|
204
|
+
delete?: never;
|
|
205
|
+
options?: never;
|
|
206
|
+
head?: never;
|
|
207
|
+
patch?: never;
|
|
208
|
+
trace?: never;
|
|
209
|
+
};
|
|
210
|
+
"/api/receipt": {
|
|
211
|
+
parameters: {
|
|
212
|
+
query?: never;
|
|
213
|
+
header?: never;
|
|
214
|
+
path?: never;
|
|
215
|
+
cookie?: never;
|
|
216
|
+
};
|
|
217
|
+
/** A signed remediation receipt by its id (rc1:<sha256>): the record before a fix, the declared fix, when it went live, the record after and the verification verdict with the files that changed, signed Ed25519 over sha256(canonical JSON). Returned with the server's own check; &download=1 gives the file for the offline verifier (node crawlcheck-verify.mjs receipt.json). The id is unguessable: whoever holds it can open it */
|
|
218
|
+
get: operations["getReceipt"];
|
|
219
|
+
put?: never;
|
|
220
|
+
post?: never;
|
|
221
|
+
delete?: never;
|
|
222
|
+
options?: never;
|
|
223
|
+
head?: never;
|
|
224
|
+
patch?: never;
|
|
225
|
+
trace?: never;
|
|
226
|
+
};
|
|
227
|
+
"/api/receipt/verify": {
|
|
228
|
+
parameters: {
|
|
229
|
+
query?: never;
|
|
230
|
+
header?: never;
|
|
231
|
+
path?: never;
|
|
232
|
+
cookie?: never;
|
|
233
|
+
};
|
|
234
|
+
get?: never;
|
|
235
|
+
put?: never;
|
|
236
|
+
/** Verify any remediation receipt: POST its JSON; receipt_hash, key_id, key_published, signature. Public */
|
|
237
|
+
post: operations["verifyReceipt"];
|
|
238
|
+
delete?: never;
|
|
239
|
+
options?: never;
|
|
240
|
+
head?: never;
|
|
241
|
+
patch?: never;
|
|
242
|
+
trace?: never;
|
|
243
|
+
};
|
|
244
|
+
"/api/receipts": {
|
|
245
|
+
parameters: {
|
|
246
|
+
query?: never;
|
|
247
|
+
header?: never;
|
|
248
|
+
path?: never;
|
|
249
|
+
cookie?: never;
|
|
250
|
+
};
|
|
251
|
+
/** A site's receipts, newest first (licence or owner) */
|
|
252
|
+
get: operations["listReceipts"];
|
|
253
|
+
put?: never;
|
|
254
|
+
post?: never;
|
|
255
|
+
delete?: never;
|
|
256
|
+
options?: never;
|
|
257
|
+
head?: never;
|
|
258
|
+
patch?: never;
|
|
259
|
+
trace?: never;
|
|
260
|
+
};
|
|
261
|
+
"/api/rollback": {
|
|
262
|
+
parameters: {
|
|
263
|
+
query?: never;
|
|
264
|
+
header?: never;
|
|
265
|
+
path?: never;
|
|
266
|
+
cookie?: never;
|
|
267
|
+
};
|
|
268
|
+
/** Compare the record before a fix with the record after it (licence or owner): findings cleared and new by fingerprint, rows now passing and now failing, every machine file whose bytes changed, a verdict (improved / unchanged / mixed / regressed), each regression pinned to the changed file it reads, and the rollback step for that file (restore the stored bytes, or remove a file that did not exist before) */
|
|
269
|
+
get: operations["verifyAndRollback"];
|
|
270
|
+
put?: never;
|
|
271
|
+
post?: never;
|
|
272
|
+
delete?: never;
|
|
273
|
+
options?: never;
|
|
274
|
+
head?: never;
|
|
275
|
+
patch?: never;
|
|
276
|
+
trace?: never;
|
|
277
|
+
};
|
|
278
|
+
"/api/rollback/file": {
|
|
279
|
+
parameters: {
|
|
280
|
+
query?: never;
|
|
281
|
+
header?: never;
|
|
282
|
+
path?: never;
|
|
283
|
+
cookie?: never;
|
|
284
|
+
};
|
|
285
|
+
/** The exact bytes a machine file served in a given record, from the artifact store, re-hashed before they are returned (licence or owner) */
|
|
286
|
+
get: operations["rollbackFile"];
|
|
287
|
+
put?: never;
|
|
288
|
+
post?: never;
|
|
289
|
+
delete?: never;
|
|
290
|
+
options?: never;
|
|
291
|
+
head?: never;
|
|
292
|
+
patch?: never;
|
|
293
|
+
trace?: never;
|
|
294
|
+
};
|
|
295
|
+
"/api/impact": {
|
|
296
|
+
parameters: {
|
|
297
|
+
query?: never;
|
|
298
|
+
header?: never;
|
|
299
|
+
path?: never;
|
|
300
|
+
cookie?: never;
|
|
301
|
+
};
|
|
302
|
+
/** What fixing one thing changes on a record (licence or owner): per fix - robots, sitemap, llms, entitymap, edge-bots, cache, page-code, chain, hsts, host-pair - the findings and rows it clears, the ones it clears only together with another fix, the root causes it closes, the certificate criteria it flips and the score and letter after */
|
|
303
|
+
get: operations["fixImpact"];
|
|
304
|
+
put?: never;
|
|
305
|
+
/** The same with a body: {id, fix:[ids]} */
|
|
306
|
+
post: operations["fixImpactPost"];
|
|
307
|
+
delete?: never;
|
|
308
|
+
options?: never;
|
|
309
|
+
head?: never;
|
|
310
|
+
patch?: never;
|
|
311
|
+
trace?: never;
|
|
312
|
+
};
|
|
313
|
+
"/api/whatif": {
|
|
314
|
+
parameters: {
|
|
315
|
+
query?: never;
|
|
316
|
+
header?: never;
|
|
317
|
+
path?: never;
|
|
318
|
+
cookie?: never;
|
|
319
|
+
};
|
|
320
|
+
/** Recompute the score and letter for a record with any set of failing rows passing and findings cleared (licence or owner): the combined effect, which individual points cannot give, plus the least set that reaches the next letter */
|
|
321
|
+
get: operations["whatIf"];
|
|
322
|
+
put?: never;
|
|
323
|
+
/** The same, with rows to fix: {id, fix:[{section_id,row}], clear:[codes]} */
|
|
324
|
+
post: operations["whatIfPost"];
|
|
325
|
+
delete?: never;
|
|
326
|
+
options?: never;
|
|
327
|
+
head?: never;
|
|
328
|
+
patch?: never;
|
|
329
|
+
trace?: never;
|
|
330
|
+
};
|
|
331
|
+
"/schemas/machine-experience-record.json": {
|
|
332
|
+
parameters: {
|
|
333
|
+
query?: never;
|
|
334
|
+
header?: never;
|
|
335
|
+
path?: never;
|
|
336
|
+
cookie?: never;
|
|
337
|
+
};
|
|
338
|
+
/** JSON Schema (2020-12) for the sealed scan manifest: every fetch a scan made, as which identity, with which headers, what came back and whether the bytes were kept; validated against 221 sealed manifests */
|
|
339
|
+
get: operations["getMachineExperienceRecordSchema"];
|
|
340
|
+
put?: never;
|
|
341
|
+
post?: never;
|
|
342
|
+
delete?: never;
|
|
343
|
+
options?: never;
|
|
344
|
+
head?: never;
|
|
345
|
+
patch?: never;
|
|
346
|
+
trace?: never;
|
|
347
|
+
};
|
|
348
|
+
"/api/v1/schema": {
|
|
349
|
+
parameters: {
|
|
350
|
+
query?: never;
|
|
351
|
+
header?: never;
|
|
352
|
+
path?: never;
|
|
353
|
+
cookie?: never;
|
|
354
|
+
};
|
|
355
|
+
/** JSON Schema for every v1 response */
|
|
356
|
+
get: operations["getSchemaV1"];
|
|
357
|
+
put?: never;
|
|
358
|
+
post?: never;
|
|
359
|
+
delete?: never;
|
|
360
|
+
options?: never;
|
|
361
|
+
head?: never;
|
|
362
|
+
patch?: never;
|
|
363
|
+
trace?: never;
|
|
364
|
+
};
|
|
365
|
+
"/api/keys": {
|
|
366
|
+
parameters: {
|
|
367
|
+
query?: never;
|
|
368
|
+
header?: never;
|
|
369
|
+
path?: never;
|
|
370
|
+
cookie?: never;
|
|
371
|
+
};
|
|
372
|
+
/** List the scoped API keys on a licence (names, scopes, last use; never the keys) */
|
|
373
|
+
get: operations["listApiKeys"];
|
|
374
|
+
put?: never;
|
|
375
|
+
/** Create a scoped API key (shown once; stored as a SHA-256) */
|
|
376
|
+
post: operations["createApiKey"];
|
|
377
|
+
/** Revoke an API key by id */
|
|
378
|
+
delete: operations["revokeApiKey"];
|
|
379
|
+
options?: never;
|
|
380
|
+
head?: never;
|
|
381
|
+
patch?: never;
|
|
382
|
+
trace?: never;
|
|
383
|
+
};
|
|
384
|
+
"/api/share": {
|
|
385
|
+
parameters: {
|
|
386
|
+
query?: never;
|
|
387
|
+
header?: never;
|
|
388
|
+
path?: never;
|
|
389
|
+
cookie?: never;
|
|
390
|
+
};
|
|
391
|
+
get?: never;
|
|
392
|
+
put?: never;
|
|
393
|
+
/** Create a scoped share link for one report (licence required; up to 90 days; revocable) */
|
|
394
|
+
post: operations["createShareLink"];
|
|
395
|
+
/** Revoke a share link created with the same licence */
|
|
396
|
+
delete: operations["revokeShareLink"];
|
|
397
|
+
options?: never;
|
|
398
|
+
head?: never;
|
|
399
|
+
patch?: never;
|
|
400
|
+
trace?: never;
|
|
401
|
+
};
|
|
402
|
+
"/api/scan/licensed": {
|
|
403
|
+
parameters: {
|
|
404
|
+
query?: never;
|
|
405
|
+
header?: never;
|
|
406
|
+
path?: never;
|
|
407
|
+
cookie?: never;
|
|
408
|
+
};
|
|
409
|
+
get?: never;
|
|
410
|
+
put?: never;
|
|
411
|
+
/** Scan a domain on the licensed lane (valid licence key required; 60 scans per ten minutes per key; 404 without a key) */
|
|
412
|
+
post: operations["scanDomainLicensed"];
|
|
413
|
+
delete?: never;
|
|
414
|
+
options?: never;
|
|
415
|
+
head?: never;
|
|
416
|
+
patch?: never;
|
|
417
|
+
trace?: never;
|
|
418
|
+
};
|
|
419
|
+
"/api/tool/wba": {
|
|
420
|
+
parameters: {
|
|
421
|
+
query?: never;
|
|
422
|
+
header?: never;
|
|
423
|
+
path?: never;
|
|
424
|
+
cookie?: never;
|
|
425
|
+
};
|
|
426
|
+
/** Audit a Web Bot Auth key directory: no redirects, content type, RFC 7638 thumbprints, and which keys the directory's own signatures prove */
|
|
427
|
+
get: operations["checkBotKeyDirectory"];
|
|
428
|
+
put?: never;
|
|
429
|
+
/** Verify a pasted Web Bot Auth request: the agent's directory, then the request's signature against a key the directory proves it holds */
|
|
430
|
+
post: operations["verifySignedBotRequest"];
|
|
431
|
+
delete?: never;
|
|
432
|
+
options?: never;
|
|
433
|
+
head?: never;
|
|
434
|
+
patch?: never;
|
|
435
|
+
trace?: never;
|
|
436
|
+
};
|
|
437
|
+
"/api/tool/verify": {
|
|
438
|
+
parameters: {
|
|
439
|
+
query?: never;
|
|
440
|
+
header?: never;
|
|
441
|
+
path?: never;
|
|
442
|
+
cookie?: never;
|
|
443
|
+
};
|
|
444
|
+
get?: never;
|
|
445
|
+
put?: never;
|
|
446
|
+
/** Adjudicate crawler identity claims in raw access-log lines against each operator's published IP ranges */
|
|
447
|
+
post: operations["verifyCrawlerLog"];
|
|
448
|
+
delete?: never;
|
|
449
|
+
options?: never;
|
|
450
|
+
head?: never;
|
|
451
|
+
patch?: never;
|
|
452
|
+
trace?: never;
|
|
453
|
+
};
|
|
454
|
+
"/api/depth": {
|
|
455
|
+
parameters: {
|
|
456
|
+
query?: never;
|
|
457
|
+
header?: never;
|
|
458
|
+
path?: never;
|
|
459
|
+
cookie?: never;
|
|
460
|
+
};
|
|
461
|
+
get?: never;
|
|
462
|
+
put?: never;
|
|
463
|
+
/** Crawl the URLs the site declares and map the links between them: orphans, undeclared pages, per-page status, canonical, text ratio, JSON-LD, noindex. Up to 300 pages in one pass; pages up to 500 (Watch, Studio) or 5000 (Agency, Network) runs as a background job in chunks of 300, advanced by every poll of /api/depth/{id} and every hour. Sites declaring more than the cap are sampled across path families. Licence-gated; 404 without a key. Returns 202 with a job id */
|
|
464
|
+
post: operations["depthCrawl"];
|
|
465
|
+
delete?: never;
|
|
466
|
+
options?: never;
|
|
467
|
+
head?: never;
|
|
468
|
+
patch?: never;
|
|
469
|
+
trace?: never;
|
|
470
|
+
};
|
|
471
|
+
"/api/depth/{id}": {
|
|
472
|
+
parameters: {
|
|
473
|
+
query?: never;
|
|
474
|
+
header?: never;
|
|
475
|
+
path?: never;
|
|
476
|
+
cookie?: never;
|
|
477
|
+
};
|
|
478
|
+
/** The depth-crawl record for a job id: orphans, undeclared, pages[], medians and stated limits */
|
|
479
|
+
get: operations["depthResult"];
|
|
480
|
+
put?: never;
|
|
481
|
+
post?: never;
|
|
482
|
+
delete?: never;
|
|
483
|
+
options?: never;
|
|
484
|
+
head?: never;
|
|
485
|
+
patch?: never;
|
|
486
|
+
trace?: never;
|
|
487
|
+
};
|
|
488
|
+
"/api/usage": {
|
|
489
|
+
parameters: {
|
|
490
|
+
query?: never;
|
|
491
|
+
header?: never;
|
|
492
|
+
path?: never;
|
|
493
|
+
cookie?: never;
|
|
494
|
+
};
|
|
495
|
+
/** This key's monthly scan quota and usage; every keyed response also carries x-crawlcheck-quota-* headers */
|
|
496
|
+
get: operations["usage"];
|
|
497
|
+
put?: never;
|
|
498
|
+
post?: never;
|
|
499
|
+
delete?: never;
|
|
500
|
+
options?: never;
|
|
501
|
+
head?: never;
|
|
502
|
+
patch?: never;
|
|
503
|
+
trace?: never;
|
|
504
|
+
};
|
|
505
|
+
"/api/verify": {
|
|
506
|
+
parameters: {
|
|
507
|
+
query?: never;
|
|
508
|
+
header?: never;
|
|
509
|
+
path?: never;
|
|
510
|
+
cookie?: never;
|
|
511
|
+
};
|
|
512
|
+
/** Every verifier in one call: record digest, seal + Bitcoin anchor, manifest signature (WBA Ed25519), stored manifest bytes, kept artifacts, decision pointers, provenance envelope, self-audit. Public */
|
|
513
|
+
get: operations["verifyRecord"];
|
|
514
|
+
put?: never;
|
|
515
|
+
post?: never;
|
|
516
|
+
delete?: never;
|
|
517
|
+
options?: never;
|
|
518
|
+
head?: never;
|
|
519
|
+
patch?: never;
|
|
520
|
+
trace?: never;
|
|
521
|
+
};
|
|
522
|
+
"/api/bundle": {
|
|
523
|
+
parameters: {
|
|
524
|
+
query?: never;
|
|
525
|
+
header?: never;
|
|
526
|
+
path?: never;
|
|
527
|
+
cookie?: never;
|
|
528
|
+
};
|
|
529
|
+
/** One evidence bundle that verifies offline: signed manifest + public key, record digest, Merkle path, the day's .ots bytes; the sealed subject with a licence covering the domain. Verify with /crawlcheck-verify.mjs. Public */
|
|
530
|
+
get: operations["evidenceBundle"];
|
|
531
|
+
put?: never;
|
|
532
|
+
post?: never;
|
|
533
|
+
delete?: never;
|
|
534
|
+
options?: never;
|
|
535
|
+
head?: never;
|
|
536
|
+
patch?: never;
|
|
537
|
+
trace?: never;
|
|
538
|
+
};
|
|
539
|
+
"/api/reconstruction": {
|
|
540
|
+
parameters: {
|
|
541
|
+
query?: never;
|
|
542
|
+
header?: never;
|
|
543
|
+
path?: never;
|
|
544
|
+
cookie?: never;
|
|
545
|
+
};
|
|
546
|
+
/** The last reconstruction test: the oldest archived records' evidence paths (record, report node, decision nodes, manifest node, every verifier check) resolved through the 90-day projections and again from the permanent store alone (R2 archive + seal records), compared byte for byte after canonical serialisation. Public */
|
|
547
|
+
get: operations["reconstructionTest"];
|
|
548
|
+
put?: never;
|
|
549
|
+
post?: never;
|
|
550
|
+
delete?: never;
|
|
551
|
+
options?: never;
|
|
552
|
+
head?: never;
|
|
553
|
+
patch?: never;
|
|
554
|
+
trace?: never;
|
|
555
|
+
};
|
|
556
|
+
"/api/graph/{id}": {
|
|
557
|
+
parameters: {
|
|
558
|
+
query?: never;
|
|
559
|
+
header?: never;
|
|
560
|
+
path?: never;
|
|
561
|
+
cookie?: never;
|
|
562
|
+
};
|
|
563
|
+
/** Resolve a finding id (f1:), decision id (d1:), manifest/artifact sha256 or report id to its graph object: evidence, rule, provenance, supporting experiences, seal, onward links. Licence-gated */
|
|
564
|
+
get: operations["graphResolve"];
|
|
565
|
+
put?: never;
|
|
566
|
+
post?: never;
|
|
567
|
+
delete?: never;
|
|
568
|
+
options?: never;
|
|
569
|
+
head?: never;
|
|
570
|
+
patch?: never;
|
|
571
|
+
trace?: never;
|
|
572
|
+
};
|
|
573
|
+
"/api/batch": {
|
|
574
|
+
parameters: {
|
|
575
|
+
query?: never;
|
|
576
|
+
header?: never;
|
|
577
|
+
path?: never;
|
|
578
|
+
cookie?: never;
|
|
579
|
+
};
|
|
580
|
+
get?: never;
|
|
581
|
+
put?: never;
|
|
582
|
+
/** Queue up to 100 domains (500 on Agency/Network) for the same audit /api/v1/scan runs; worked at minutes 17 past each hour UTC; optional signed https webhook on completion */
|
|
583
|
+
post: operations["batchSubmit"];
|
|
584
|
+
delete?: never;
|
|
585
|
+
options?: never;
|
|
586
|
+
head?: never;
|
|
587
|
+
patch?: never;
|
|
588
|
+
trace?: never;
|
|
589
|
+
};
|
|
590
|
+
"/api/batch/{id}": {
|
|
591
|
+
parameters: {
|
|
592
|
+
query?: never;
|
|
593
|
+
header?: never;
|
|
594
|
+
path?: never;
|
|
595
|
+
cookie?: never;
|
|
596
|
+
};
|
|
597
|
+
/** Batch state and per-domain results (grade, overall, refused, report links) */
|
|
598
|
+
get: operations["batchStatus"];
|
|
599
|
+
put?: never;
|
|
600
|
+
post?: never;
|
|
601
|
+
delete?: never;
|
|
602
|
+
options?: never;
|
|
603
|
+
head?: never;
|
|
604
|
+
patch?: never;
|
|
605
|
+
trace?: never;
|
|
606
|
+
};
|
|
607
|
+
"/api/flow": {
|
|
608
|
+
parameters: {
|
|
609
|
+
query?: never;
|
|
610
|
+
header?: never;
|
|
611
|
+
path?: never;
|
|
612
|
+
cookie?: never;
|
|
613
|
+
};
|
|
614
|
+
/** The observed data flow for a domain: where each crawler identity's path dies (edge, robots.txt as a file, robots.txt rules) and which stores it reached. Uses the latest record on file, or scans first when there is none (fresh=1). Answer-engine output is drawn, never measured */
|
|
615
|
+
get: operations["crawlerFlow"];
|
|
616
|
+
put?: never;
|
|
617
|
+
post?: never;
|
|
618
|
+
delete?: never;
|
|
619
|
+
options?: never;
|
|
620
|
+
head?: never;
|
|
621
|
+
patch?: never;
|
|
622
|
+
trace?: never;
|
|
623
|
+
};
|
|
624
|
+
"/api/flow/gate": {
|
|
625
|
+
parameters: {
|
|
626
|
+
query?: never;
|
|
627
|
+
header?: never;
|
|
628
|
+
path?: never;
|
|
629
|
+
cookie?: never;
|
|
630
|
+
};
|
|
631
|
+
/** CI gate for a domain the key covers: 200 pass, 412 fail when a crawler path open at the last sealed scan closed, a file broke, or a declared path is violated at critical/high */
|
|
632
|
+
get: operations["flowGate"];
|
|
633
|
+
put?: never;
|
|
634
|
+
post?: never;
|
|
635
|
+
delete?: never;
|
|
636
|
+
options?: never;
|
|
637
|
+
head?: never;
|
|
638
|
+
patch?: never;
|
|
639
|
+
trace?: never;
|
|
640
|
+
};
|
|
641
|
+
"/api/flow/declared": {
|
|
642
|
+
parameters: {
|
|
643
|
+
query?: never;
|
|
644
|
+
header?: never;
|
|
645
|
+
path?: never;
|
|
646
|
+
cookie?: never;
|
|
647
|
+
};
|
|
648
|
+
/** The owner's declared flow for a domain the key covers, with parity against the latest scan */
|
|
649
|
+
get: operations["flowDeclaredGet"];
|
|
650
|
+
/** Set the declared flow: agents {id: reach|blocked|any}, stores {id: present|absent|any}, or {seed: observed} to start from the latest scan */
|
|
651
|
+
put: operations["flowDeclaredPut"];
|
|
652
|
+
post?: never;
|
|
653
|
+
/** Remove the declared flow */
|
|
654
|
+
delete: operations["flowDeclaredDelete"];
|
|
655
|
+
options?: never;
|
|
656
|
+
head?: never;
|
|
657
|
+
patch?: never;
|
|
658
|
+
trace?: never;
|
|
659
|
+
};
|
|
660
|
+
"/api/tool/robots": {
|
|
661
|
+
parameters: {
|
|
662
|
+
query?: never;
|
|
663
|
+
header?: never;
|
|
664
|
+
path?: never;
|
|
665
|
+
cookie?: never;
|
|
666
|
+
};
|
|
667
|
+
/** Resolve every named answer engine, search index and training crawler against a domain's robots.txt the way a crawler does: most-specific group only, longest match, allow wins a tie */
|
|
668
|
+
get: operations["robotsResolve"];
|
|
669
|
+
put?: never;
|
|
670
|
+
post?: never;
|
|
671
|
+
delete?: never;
|
|
672
|
+
options?: never;
|
|
673
|
+
head?: never;
|
|
674
|
+
patch?: never;
|
|
675
|
+
trace?: never;
|
|
676
|
+
};
|
|
677
|
+
"/api/tool/llms": {
|
|
678
|
+
parameters: {
|
|
679
|
+
query?: never;
|
|
680
|
+
header?: never;
|
|
681
|
+
path?: never;
|
|
682
|
+
cookie?: never;
|
|
683
|
+
};
|
|
684
|
+
/** Draft an llms.txt from the domain's own homepage and up to 25 declared pages, using their titles and descriptions. A draft, not a publication */
|
|
685
|
+
get: operations["llmsDraft"];
|
|
686
|
+
put?: never;
|
|
687
|
+
post?: never;
|
|
688
|
+
delete?: never;
|
|
689
|
+
options?: never;
|
|
690
|
+
head?: never;
|
|
691
|
+
patch?: never;
|
|
692
|
+
trace?: never;
|
|
693
|
+
};
|
|
694
|
+
"/api/video": {
|
|
695
|
+
parameters: {
|
|
696
|
+
query?: never;
|
|
697
|
+
header?: never;
|
|
698
|
+
path?: never;
|
|
699
|
+
cookie?: never;
|
|
700
|
+
};
|
|
701
|
+
/** One YouTube video against the video anchor model: twelve checks, each naming what it reads. Cached six hours */
|
|
702
|
+
get: operations["videoCheck"];
|
|
703
|
+
put?: never;
|
|
704
|
+
post?: never;
|
|
705
|
+
delete?: never;
|
|
706
|
+
options?: never;
|
|
707
|
+
head?: never;
|
|
708
|
+
patch?: never;
|
|
709
|
+
trace?: never;
|
|
710
|
+
};
|
|
711
|
+
"/api/video/channel": {
|
|
712
|
+
parameters: {
|
|
713
|
+
query?: never;
|
|
714
|
+
header?: never;
|
|
715
|
+
path?: never;
|
|
716
|
+
cookie?: never;
|
|
717
|
+
};
|
|
718
|
+
/** Every upload on a channel, read 50 at a time. The upload list is free; the per-check tally (checks=1) is for Watch licences and above */
|
|
719
|
+
get: operations["videoChannel"];
|
|
720
|
+
put?: never;
|
|
721
|
+
post?: never;
|
|
722
|
+
delete?: never;
|
|
723
|
+
options?: never;
|
|
724
|
+
head?: never;
|
|
725
|
+
patch?: never;
|
|
726
|
+
trace?: never;
|
|
727
|
+
};
|
|
728
|
+
"/api/video/site": {
|
|
729
|
+
parameters: {
|
|
730
|
+
query?: never;
|
|
731
|
+
header?: never;
|
|
732
|
+
path?: never;
|
|
733
|
+
cookie?: never;
|
|
734
|
+
};
|
|
735
|
+
/** The site half: homepage plus up to 60 sitemap pages read for YouTube embeds, facades and page-builder widgets, VideoObject nodes and their required properties, and - with a handle - how many of the channel's videos the site carries */
|
|
736
|
+
get: operations["videoSite"];
|
|
737
|
+
put?: never;
|
|
738
|
+
post?: never;
|
|
739
|
+
delete?: never;
|
|
740
|
+
options?: never;
|
|
741
|
+
head?: never;
|
|
742
|
+
patch?: never;
|
|
743
|
+
trace?: never;
|
|
744
|
+
};
|
|
745
|
+
"/api/fix/robots": {
|
|
746
|
+
parameters: {
|
|
747
|
+
query?: never;
|
|
748
|
+
header?: never;
|
|
749
|
+
path?: never;
|
|
750
|
+
cookie?: never;
|
|
751
|
+
};
|
|
752
|
+
/** The served robots.txt, corrected: * group rules copied into every named group that lacked them, a Sitemap line added when the file never named the sitemap it serves, a minimal replacement when the served file was HTML. Every change is listed at the top of the file */
|
|
753
|
+
get: operations["fixRobots"];
|
|
754
|
+
put?: never;
|
|
755
|
+
post?: never;
|
|
756
|
+
delete?: never;
|
|
757
|
+
options?: never;
|
|
758
|
+
head?: never;
|
|
759
|
+
patch?: never;
|
|
760
|
+
trace?: never;
|
|
761
|
+
};
|
|
762
|
+
"/api/fix/entitymap": {
|
|
763
|
+
parameters: {
|
|
764
|
+
query?: never;
|
|
765
|
+
header?: never;
|
|
766
|
+
path?: never;
|
|
767
|
+
cookie?: never;
|
|
768
|
+
};
|
|
769
|
+
/** A starter entitymap.json built from the latest scan record: name, phone, coordinates and every declared service area as entities with SERVES relations. Fields the page never stated are marked TODO, never guessed. Needs a prior scan */
|
|
770
|
+
get: operations["fixEntitymap"];
|
|
771
|
+
put?: never;
|
|
772
|
+
post?: never;
|
|
773
|
+
delete?: never;
|
|
774
|
+
options?: never;
|
|
775
|
+
head?: never;
|
|
776
|
+
patch?: never;
|
|
777
|
+
trace?: never;
|
|
778
|
+
};
|
|
779
|
+
"/api/entity/observe": {
|
|
780
|
+
parameters: {
|
|
781
|
+
query?: never;
|
|
782
|
+
header?: never;
|
|
783
|
+
path?: never;
|
|
784
|
+
cookie?: never;
|
|
785
|
+
};
|
|
786
|
+
get?: never;
|
|
787
|
+
put?: never;
|
|
788
|
+
/** File a profile page as the owner's browser saw it, for the entity corroboration section. Consulted only where the scanner's own fetch was unverifiable; never overrides a live result; the row is labelled owner-browser. Licence-gated and bound to the licence's domains; the page's canonical must name the url's host. Kept 30 days */
|
|
789
|
+
post: operations["entityObserve"];
|
|
790
|
+
delete?: never;
|
|
791
|
+
options?: never;
|
|
792
|
+
head?: never;
|
|
793
|
+
patch?: never;
|
|
794
|
+
trace?: never;
|
|
795
|
+
};
|
|
796
|
+
"/api/public/counts": {
|
|
797
|
+
parameters: {
|
|
798
|
+
query?: never;
|
|
799
|
+
header?: never;
|
|
800
|
+
path?: never;
|
|
801
|
+
cookie?: never;
|
|
802
|
+
};
|
|
803
|
+
/** The figures this site quotes about itself: sites_measured, domains_in_corpus (two different quantities), crawler_visits (a rolling window), queue, identities_sent, sections, sections_scored (derived from the weights map), findings_published, guides_published and an at timestamp. CORS open, cached 60 seconds */
|
|
804
|
+
get: operations["publicCounts"];
|
|
805
|
+
put?: never;
|
|
806
|
+
post?: never;
|
|
807
|
+
delete?: never;
|
|
808
|
+
options?: never;
|
|
809
|
+
head?: never;
|
|
810
|
+
patch?: never;
|
|
811
|
+
trace?: never;
|
|
812
|
+
};
|
|
813
|
+
"/api/registry": {
|
|
814
|
+
parameters: {
|
|
815
|
+
query?: never;
|
|
816
|
+
header?: never;
|
|
817
|
+
path?: never;
|
|
818
|
+
cookie?: never;
|
|
819
|
+
};
|
|
820
|
+
/** The registry: which measured domains serve an llms.txt, an agents.md, a media kit, a reciprocity-tested entity graph, an AI access policy that names crawlers, or agent-callable surfaces */
|
|
821
|
+
get: operations["registry"];
|
|
822
|
+
put?: never;
|
|
823
|
+
post?: never;
|
|
824
|
+
delete?: never;
|
|
825
|
+
options?: never;
|
|
826
|
+
head?: never;
|
|
827
|
+
patch?: never;
|
|
828
|
+
trace?: never;
|
|
829
|
+
};
|
|
830
|
+
"/api/telemetry": {
|
|
831
|
+
parameters: {
|
|
832
|
+
query?: never;
|
|
833
|
+
header?: never;
|
|
834
|
+
path?: never;
|
|
835
|
+
cookie?: never;
|
|
836
|
+
};
|
|
837
|
+
/** Verified-crawler telemetry observed at this origin */
|
|
838
|
+
get: operations["telemetry"];
|
|
839
|
+
put?: never;
|
|
840
|
+
post?: never;
|
|
841
|
+
delete?: never;
|
|
842
|
+
options?: never;
|
|
843
|
+
head?: never;
|
|
844
|
+
patch?: never;
|
|
845
|
+
trace?: never;
|
|
846
|
+
};
|
|
847
|
+
"/api/corpus/state": {
|
|
848
|
+
parameters: {
|
|
849
|
+
query?: never;
|
|
850
|
+
header?: never;
|
|
851
|
+
path?: never;
|
|
852
|
+
cookie?: never;
|
|
853
|
+
};
|
|
854
|
+
/** Coverage of the public dataset by platform, rendering, size, language and kind */
|
|
855
|
+
get: operations["corpusState"];
|
|
856
|
+
put?: never;
|
|
857
|
+
post?: never;
|
|
858
|
+
delete?: never;
|
|
859
|
+
options?: never;
|
|
860
|
+
head?: never;
|
|
861
|
+
patch?: never;
|
|
862
|
+
trace?: never;
|
|
863
|
+
};
|
|
864
|
+
}
|
|
865
|
+
export type webhooks = Record<string, never>;
|
|
866
|
+
export interface components {
|
|
867
|
+
schemas: {
|
|
868
|
+
ScanRecord: {
|
|
869
|
+
/** @description Report id; the report renders at /r/{id} and the record at /r/{id}.json */
|
|
870
|
+
id?: string;
|
|
871
|
+
domain?: string;
|
|
872
|
+
/**
|
|
873
|
+
* @description null when the origin refused the scanner or the scan could not be graded
|
|
874
|
+
* @enum {string|null}
|
|
875
|
+
*/
|
|
876
|
+
grade?: "A" | "B" | "C" | "D" | "F" | null;
|
|
877
|
+
/** @description AI visibility: reach, then read, then quote */
|
|
878
|
+
overall?: number | null;
|
|
879
|
+
/** @description The homepage and a path that cannot exist answered identically: a wall, not a site. Nothing is scored */
|
|
880
|
+
refused?: boolean;
|
|
881
|
+
section_scores?: {
|
|
882
|
+
id?: string;
|
|
883
|
+
title?: string;
|
|
884
|
+
score?: number | null;
|
|
885
|
+
}[];
|
|
886
|
+
findings?: {
|
|
887
|
+
code?: string;
|
|
888
|
+
severity?: number;
|
|
889
|
+
path?: string;
|
|
890
|
+
title?: string;
|
|
891
|
+
detail?: string;
|
|
892
|
+
evidence?: unknown;
|
|
893
|
+
}[];
|
|
894
|
+
/** @description Invariants checked on this record itself; a finding here is a defect in the scanner, never in the site */
|
|
895
|
+
self_audit?: Record<string, never>;
|
|
896
|
+
};
|
|
897
|
+
VerifyResult: {
|
|
898
|
+
tally?: {
|
|
899
|
+
verified?: number;
|
|
900
|
+
spoofed?: number;
|
|
901
|
+
unverifiable?: number;
|
|
902
|
+
no_bot?: number;
|
|
903
|
+
};
|
|
904
|
+
forged_rate_pct?: number | null;
|
|
905
|
+
denominator_note?: string;
|
|
906
|
+
rows?: Record<string, never>[];
|
|
907
|
+
};
|
|
908
|
+
PublicReportV1: {
|
|
909
|
+
schema: string;
|
|
910
|
+
/** @constant */
|
|
911
|
+
version: "1.0";
|
|
912
|
+
id: string | null;
|
|
913
|
+
domain: string | null;
|
|
914
|
+
path?: string | null;
|
|
915
|
+
scanned_host?: string | null;
|
|
916
|
+
scanned_at: string | null;
|
|
917
|
+
score_version?: number | null;
|
|
918
|
+
grade: string | null;
|
|
919
|
+
overall: number | null;
|
|
920
|
+
grade_detail?: {
|
|
921
|
+
capped?: boolean;
|
|
922
|
+
cap?: string | null;
|
|
923
|
+
cap_reason?: string | null;
|
|
924
|
+
};
|
|
925
|
+
sections: {
|
|
926
|
+
id?: string | null;
|
|
927
|
+
title?: string | null;
|
|
928
|
+
/** @description null means not measured, never zero */
|
|
929
|
+
score?: number | null;
|
|
930
|
+
}[];
|
|
931
|
+
findings: {
|
|
932
|
+
code?: string | null;
|
|
933
|
+
path?: string | null;
|
|
934
|
+
severity?: number | null;
|
|
935
|
+
title?: string | null;
|
|
936
|
+
detail?: string | null;
|
|
937
|
+
meaning?: string | null;
|
|
938
|
+
evidence?: string | null;
|
|
939
|
+
fid?: string | null;
|
|
940
|
+
decision_id?: string | null;
|
|
941
|
+
graph?: string | null;
|
|
942
|
+
/** @description true on an unlicensed read for every finding but the top one: title, severity and path are present, the rest is withheld */
|
|
943
|
+
locked?: boolean;
|
|
944
|
+
/** @description code|path; stable across scans of the same domain; null on a locked finding */
|
|
945
|
+
fingerprint?: string | null;
|
|
946
|
+
/**
|
|
947
|
+
* @description lifecycle on this scan; null when the domain has no stored history
|
|
948
|
+
* @enum {string|null}
|
|
949
|
+
*/
|
|
950
|
+
state?: "new" | "persisted" | "worsened" | "improved" | "regressed" | "resolved" | "rule-changed" | null;
|
|
951
|
+
first_seen?: string | null;
|
|
952
|
+
scans_seen?: number | null;
|
|
953
|
+
recurrences?: number | null;
|
|
954
|
+
/** @description bitemporal: when the condition held on the site (valid_from / valid_to as after-by intervals between observations; null ends are unknown or still open) and when CrawlCheck recorded it (recorded_at, superseded_at) */
|
|
955
|
+
valid_time?: Record<string, never> | null;
|
|
956
|
+
}[];
|
|
957
|
+
/** @description Set on an unlicensed read: every finding is listed by title, severity and path; detail, evidence and code beyond the top one are withheld */
|
|
958
|
+
findings_withheld?: string | null;
|
|
959
|
+
findings_summary?: {
|
|
960
|
+
total?: number | null;
|
|
961
|
+
serious?: number | null;
|
|
962
|
+
by_severity?: Record<string, never> | null;
|
|
963
|
+
} | null;
|
|
964
|
+
/** @description Observer build, vantage, rule version, observed and stored times, sealed manifest */
|
|
965
|
+
provenance?: Record<string, never> | null;
|
|
966
|
+
/** @description Findings that share one cause or one fix, formed only from evidence in this record (e.g. robots.txt, the sitemap and llms.txt all answering with the site's HTML page). With a licence: cause, fix, generators, evidence and members. An unlicensed v1 read is built from the locked record, so the list is empty there; /api/v1/machine-record shows a group the top finding belongs to, by kind and size */
|
|
967
|
+
root_causes?: unknown[] | null;
|
|
968
|
+
/** @description One line per fix that would change this record (robots, sitemap, llms, entitymap, edge-bots, cache, page-code, chain, hsts, host-pair), best first: findings and rows it clears, the other fixes some of its rows also need, the score and letter after (the formula rerun), root causes it closes and certificate criteria it flips. Null on an unlicensed read; /api/impact has the names */
|
|
969
|
+
fix_impact?: unknown[] | null;
|
|
970
|
+
/** @description combined {all_rows_fixed, all_findings_cleared, both} and next_letter {target, reachable, ...} are recomputed, never summed. What each decision moved. rows[]: every failing scored row with points = the score recomputed with that row passing minus the score now (same formula, Reach + 15 ceiling included), points_section_average, and why a row moves nothing; withheld (rows_withheld) where the fix list is. Findings move no points: each finding's score_effect states the letter cap it sets, whether it binds, and the letter without it. */
|
|
971
|
+
score_ledger?: Record<string, never> | null;
|
|
972
|
+
/** @description Counts and ratios behind the reading: sections_scored, identities_answered, fetches_kept, stage_failures, non_observations, vantages. No composite number, because the parts do not combine into one honestly */
|
|
973
|
+
confidence?: Record<string, never> | null;
|
|
974
|
+
/** @description Each stated fact with two times: when CrawlCheck observed it (observed_from, observed_last, removed_at) and when the site says it became true (valid time, null when the site does not say) */
|
|
975
|
+
bitemporal?: Record<string, never> | null;
|
|
976
|
+
/** @description What was not measured on this scan and why; an unmeasured subject is never scored as a pass or a fail */
|
|
977
|
+
non_observations?: {
|
|
978
|
+
subject?: string | null;
|
|
979
|
+
state?: string | null;
|
|
980
|
+
reason?: string | null;
|
|
981
|
+
attempted?: boolean | null;
|
|
982
|
+
}[] | null;
|
|
983
|
+
/** @description Each value carries locators[] (one per source): bytes [start, end) in the page this scan received, line, col, scope (meta[og:title], script[ld+json]#0, title, page text) and match (value | property | normalised | partial), or {found:false, why}; check them with /api/locate. Each business fact (name, phone, address, email, founder) with every value the site stated and where it stated it, and whether the statements agree */
|
|
984
|
+
fact_lineage?: Record<string, never> | null;
|
|
985
|
+
checks?: {
|
|
986
|
+
path?: string | null;
|
|
987
|
+
status?: number | null;
|
|
988
|
+
bytes?: number | null;
|
|
989
|
+
}[];
|
|
990
|
+
agentview?: {
|
|
991
|
+
label?: string | null;
|
|
992
|
+
status?: number | null;
|
|
993
|
+
words?: number | null;
|
|
994
|
+
}[];
|
|
995
|
+
nap?: Record<string, never> | null;
|
|
996
|
+
headroom?: {
|
|
997
|
+
gain?: number | null;
|
|
998
|
+
failing?: number | null;
|
|
999
|
+
} | null;
|
|
1000
|
+
history?: {
|
|
1001
|
+
at?: string | null;
|
|
1002
|
+
overall?: number | null;
|
|
1003
|
+
score_version?: number | null;
|
|
1004
|
+
}[];
|
|
1005
|
+
proof: {
|
|
1006
|
+
digest?: string | null;
|
|
1007
|
+
algorithm?: string | null;
|
|
1008
|
+
anchored?: string | null;
|
|
1009
|
+
verify?: string | null;
|
|
1010
|
+
};
|
|
1011
|
+
links?: Record<string, never>;
|
|
1012
|
+
};
|
|
1013
|
+
/** @description One observation in one shape (GET /api/v1/machine-record, MCP machine_record): subject, observation, findings (top in full without a licence; the rest locked), capabilities with safety class and verification state, evidence roots and verifier links */
|
|
1014
|
+
MachineRecordV1: {
|
|
1015
|
+
/** @constant */
|
|
1016
|
+
kind: "crawlcheck-machine-record";
|
|
1017
|
+
version: string;
|
|
1018
|
+
subject: Record<string, never>;
|
|
1019
|
+
observation: Record<string, never>;
|
|
1020
|
+
/** @description each open finding carries trust {freshness, confidence {level, means, basis[]}, contradictions[]} */
|
|
1021
|
+
findings: unknown[];
|
|
1022
|
+
/** @description observed_at, age_hours, latest_report_id, is_latest, newer_scan_exists, last_second_reading_at */
|
|
1023
|
+
freshness?: Record<string, never>;
|
|
1024
|
+
/** @description With a licence: one line per fix that would change this record, best first (findings and rows it clears, other fixes some rows also need, score and letter after, root causes closed, certificate criteria flipped). Without: {fixes_available, best_single_fix {letter_after, score_after, findings_cleared, rows_cleared}} and no names */
|
|
1025
|
+
fix_impact?: unknown[] | Record<string, never> | null;
|
|
1026
|
+
/** @description score, letter, cap and the points each failing row moves (rows open with a licence); each open finding carries score_effect {points: 0, cap, binding, letter_without_it, says} */
|
|
1027
|
+
score_ledger?: Record<string, never> | null;
|
|
1028
|
+
/** @description counts and ratios plus vantages; no composite number; levels: contested | cross_vantage_confirmed | reproduced | single_reading */
|
|
1029
|
+
confidence?: Record<string, never>;
|
|
1030
|
+
/** @description site (the site contradicts itself) and between_networks_open (observers disagree), for findings this caller can open */
|
|
1031
|
+
contradictions?: Record<string, never>;
|
|
1032
|
+
findings_summary?: Record<string, never> | null;
|
|
1033
|
+
findings_withheld?: string | null;
|
|
1034
|
+
capabilities: Record<string, never>;
|
|
1035
|
+
evidence: Record<string, never>;
|
|
1036
|
+
access: Record<string, never>;
|
|
1037
|
+
};
|
|
1038
|
+
ErrorV1: {
|
|
1039
|
+
error: {
|
|
1040
|
+
code: string;
|
|
1041
|
+
status?: number;
|
|
1042
|
+
message: string;
|
|
1043
|
+
};
|
|
1044
|
+
};
|
|
1045
|
+
/** @description GET /api/bundle: one file that checks offline with /crawlcheck-verify.mjs. A field that cannot be filled (an anonymous download, an unsealed day, a record from before manifests) is null with a *_withheld / *_missing / why reason, never omitted */
|
|
1046
|
+
EvidenceBundleV1: {
|
|
1047
|
+
/** @constant */
|
|
1048
|
+
kind: "crawlcheck-evidence-bundle";
|
|
1049
|
+
version: number;
|
|
1050
|
+
generated_at?: string;
|
|
1051
|
+
report: {
|
|
1052
|
+
id: string | null;
|
|
1053
|
+
domain: string | null;
|
|
1054
|
+
path?: string | null;
|
|
1055
|
+
scanned_at: string | null;
|
|
1056
|
+
score_version?: number | null;
|
|
1057
|
+
archived?: boolean;
|
|
1058
|
+
};
|
|
1059
|
+
verifier: {
|
|
1060
|
+
url: string;
|
|
1061
|
+
sha256: string;
|
|
1062
|
+
run?: string;
|
|
1063
|
+
page?: string;
|
|
1064
|
+
};
|
|
1065
|
+
proves?: string[];
|
|
1066
|
+
does_not_prove?: string[];
|
|
1067
|
+
manifest: {
|
|
1068
|
+
sha256: string;
|
|
1069
|
+
body: string | null;
|
|
1070
|
+
body_missing?: string | null;
|
|
1071
|
+
signature?: {
|
|
1072
|
+
alg?: string | null;
|
|
1073
|
+
kid?: string | null;
|
|
1074
|
+
message?: string | null;
|
|
1075
|
+
sig?: string | null;
|
|
1076
|
+
signed_at?: string | null;
|
|
1077
|
+
} | null;
|
|
1078
|
+
key?: {
|
|
1079
|
+
jwk?: {
|
|
1080
|
+
/** @constant */
|
|
1081
|
+
kty: "OKP";
|
|
1082
|
+
/** @constant */
|
|
1083
|
+
crv: "Ed25519";
|
|
1084
|
+
x: string;
|
|
1085
|
+
};
|
|
1086
|
+
kid?: string;
|
|
1087
|
+
published_in?: string;
|
|
1088
|
+
} | null;
|
|
1089
|
+
key_missing?: string | null;
|
|
1090
|
+
} | null;
|
|
1091
|
+
record: {
|
|
1092
|
+
digest: string | null;
|
|
1093
|
+
subject: string | null;
|
|
1094
|
+
subject_withheld?: string | null;
|
|
1095
|
+
recipe?: string | null;
|
|
1096
|
+
decision_leaves?: Record<string, never>[] | null;
|
|
1097
|
+
lineage_leaves?: Record<string, never>[] | null;
|
|
1098
|
+
leaves_withheld?: string | null;
|
|
1099
|
+
};
|
|
1100
|
+
seal: {
|
|
1101
|
+
/** @enum {unknown} */
|
|
1102
|
+
state: "sealed" | "pending" | "unsealed" | "unverifiable" | "unknown";
|
|
1103
|
+
day?: string | null;
|
|
1104
|
+
root?: string | null;
|
|
1105
|
+
path?: {
|
|
1106
|
+
/** @enum {unknown} */
|
|
1107
|
+
side: "left" | "right";
|
|
1108
|
+
hash: string;
|
|
1109
|
+
}[];
|
|
1110
|
+
leaves_that_day?: number | null;
|
|
1111
|
+
sealed_at?: string | null;
|
|
1112
|
+
calendars?: string[];
|
|
1113
|
+
ots_base64?: string | null;
|
|
1114
|
+
bitcoin_block?: number | null;
|
|
1115
|
+
recipe?: string | null;
|
|
1116
|
+
why?: string | null;
|
|
1117
|
+
};
|
|
1118
|
+
};
|
|
1119
|
+
/** @description A signed remediation receipt (GET /api/receipt?id=). receipt_id = rc1: + sha256 of the canonical JSON of every field except receipt_id and signature; signature = Ed25519 over 'crawlcheck-receipt-v1\n' + that sha256 */
|
|
1120
|
+
RemediationReceiptV1: {
|
|
1121
|
+
receipt_id: string;
|
|
1122
|
+
/** @constant */
|
|
1123
|
+
kind: "crawlcheck-remediation-receipt";
|
|
1124
|
+
/** @constant */
|
|
1125
|
+
v: 1;
|
|
1126
|
+
issued_at: string;
|
|
1127
|
+
issuer: {
|
|
1128
|
+
observer?: string | null;
|
|
1129
|
+
version_id?: string | null;
|
|
1130
|
+
version_tag?: string | null;
|
|
1131
|
+
key: {
|
|
1132
|
+
kid: string;
|
|
1133
|
+
jwk: Record<string, never>;
|
|
1134
|
+
published_in?: string | null;
|
|
1135
|
+
};
|
|
1136
|
+
};
|
|
1137
|
+
subject: {
|
|
1138
|
+
domain: string;
|
|
1139
|
+
};
|
|
1140
|
+
before: components["schemas"]["ReceiptSideV1"];
|
|
1141
|
+
after: components["schemas"]["ReceiptSideV1"];
|
|
1142
|
+
declared_fix: {
|
|
1143
|
+
kind?: string;
|
|
1144
|
+
declared_by?: string | null;
|
|
1145
|
+
declared_at?: string | null;
|
|
1146
|
+
plugin_version?: string | null;
|
|
1147
|
+
fixes?: string[] | null;
|
|
1148
|
+
note?: string | null;
|
|
1149
|
+
};
|
|
1150
|
+
deployed: {
|
|
1151
|
+
at?: string | null;
|
|
1152
|
+
basis?: string | null;
|
|
1153
|
+
};
|
|
1154
|
+
verification: {
|
|
1155
|
+
/** @enum {unknown} */
|
|
1156
|
+
verdict: "improved" | "unchanged" | "mixed" | "regressed";
|
|
1157
|
+
summary?: string | null;
|
|
1158
|
+
comparable?: boolean;
|
|
1159
|
+
findings?: Record<string, never>;
|
|
1160
|
+
rows?: Record<string, never>;
|
|
1161
|
+
files?: {
|
|
1162
|
+
path?: string;
|
|
1163
|
+
state?: string;
|
|
1164
|
+
before_sha256?: string | null;
|
|
1165
|
+
after_sha256?: string | null;
|
|
1166
|
+
before_status?: number | null;
|
|
1167
|
+
after_status?: number | null;
|
|
1168
|
+
}[];
|
|
1169
|
+
rollback_needed?: boolean;
|
|
1170
|
+
rollback_steps?: Record<string, never>[];
|
|
1171
|
+
method?: string | null;
|
|
1172
|
+
};
|
|
1173
|
+
links?: Record<string, never>;
|
|
1174
|
+
signature: {
|
|
1175
|
+
v?: number | null;
|
|
1176
|
+
/** @constant */
|
|
1177
|
+
alg: "Ed25519";
|
|
1178
|
+
kid: string;
|
|
1179
|
+
over?: string | null;
|
|
1180
|
+
receipt_sha256: string;
|
|
1181
|
+
message: string;
|
|
1182
|
+
sig: string;
|
|
1183
|
+
signed_at?: string | null;
|
|
1184
|
+
canonical?: string | null;
|
|
1185
|
+
};
|
|
1186
|
+
};
|
|
1187
|
+
ReceiptSideV1: {
|
|
1188
|
+
report_id: string | null;
|
|
1189
|
+
scanned_at: string | null;
|
|
1190
|
+
grade?: string | null;
|
|
1191
|
+
score?: number | null;
|
|
1192
|
+
score_version?: number | null;
|
|
1193
|
+
refused?: boolean;
|
|
1194
|
+
findings?: number | null;
|
|
1195
|
+
manifest_sha256?: string | null;
|
|
1196
|
+
decision_root?: string | null;
|
|
1197
|
+
trace_id?: string | null;
|
|
1198
|
+
};
|
|
1199
|
+
};
|
|
1200
|
+
responses: never;
|
|
1201
|
+
parameters: never;
|
|
1202
|
+
requestBodies: never;
|
|
1203
|
+
headers: never;
|
|
1204
|
+
pathItems: never;
|
|
1205
|
+
}
|
|
1206
|
+
export type $defs = Record<string, never>;
|
|
1207
|
+
export interface operations {
|
|
1208
|
+
scan: {
|
|
1209
|
+
parameters: {
|
|
1210
|
+
query?: never;
|
|
1211
|
+
header?: never;
|
|
1212
|
+
path?: never;
|
|
1213
|
+
cookie?: never;
|
|
1214
|
+
};
|
|
1215
|
+
requestBody: {
|
|
1216
|
+
content: {
|
|
1217
|
+
"application/json": {
|
|
1218
|
+
/**
|
|
1219
|
+
* @description A bare domain or a full URL
|
|
1220
|
+
* @example example.com
|
|
1221
|
+
*/
|
|
1222
|
+
domain: string;
|
|
1223
|
+
};
|
|
1224
|
+
};
|
|
1225
|
+
};
|
|
1226
|
+
responses: {
|
|
1227
|
+
/** @description The scan record */
|
|
1228
|
+
200: {
|
|
1229
|
+
headers: {
|
|
1230
|
+
[name: string]: unknown;
|
|
1231
|
+
};
|
|
1232
|
+
content: {
|
|
1233
|
+
"application/json": components["schemas"]["ScanRecord"];
|
|
1234
|
+
};
|
|
1235
|
+
};
|
|
1236
|
+
/** @description Not a public domain, or no JSON body */
|
|
1237
|
+
400: {
|
|
1238
|
+
headers: {
|
|
1239
|
+
[name: string]: unknown;
|
|
1240
|
+
};
|
|
1241
|
+
content?: never;
|
|
1242
|
+
};
|
|
1243
|
+
/** @description Rate limited: 5 requests per 10 seconds per address */
|
|
1244
|
+
429: {
|
|
1245
|
+
headers: {
|
|
1246
|
+
[name: string]: unknown;
|
|
1247
|
+
};
|
|
1248
|
+
content?: never;
|
|
1249
|
+
};
|
|
1250
|
+
};
|
|
1251
|
+
};
|
|
1252
|
+
scanDomainV1: {
|
|
1253
|
+
parameters: {
|
|
1254
|
+
query?: never;
|
|
1255
|
+
header?: never;
|
|
1256
|
+
path?: never;
|
|
1257
|
+
cookie?: never;
|
|
1258
|
+
};
|
|
1259
|
+
requestBody: {
|
|
1260
|
+
content: {
|
|
1261
|
+
"application/json": {
|
|
1262
|
+
domain: string;
|
|
1263
|
+
};
|
|
1264
|
+
};
|
|
1265
|
+
};
|
|
1266
|
+
responses: {
|
|
1267
|
+
/** @description PublicReportV1 */
|
|
1268
|
+
200: {
|
|
1269
|
+
headers: {
|
|
1270
|
+
[name: string]: unknown;
|
|
1271
|
+
};
|
|
1272
|
+
content: {
|
|
1273
|
+
"application/json": components["schemas"]["PublicReportV1"];
|
|
1274
|
+
};
|
|
1275
|
+
};
|
|
1276
|
+
/** @description ErrorV1: bad_request */
|
|
1277
|
+
400: {
|
|
1278
|
+
headers: {
|
|
1279
|
+
[name: string]: unknown;
|
|
1280
|
+
};
|
|
1281
|
+
content?: never;
|
|
1282
|
+
};
|
|
1283
|
+
/** @description ErrorV1: rate_limited */
|
|
1284
|
+
429: {
|
|
1285
|
+
headers: {
|
|
1286
|
+
[name: string]: unknown;
|
|
1287
|
+
};
|
|
1288
|
+
content?: never;
|
|
1289
|
+
};
|
|
1290
|
+
};
|
|
1291
|
+
};
|
|
1292
|
+
getMachineRecordV1: {
|
|
1293
|
+
parameters: {
|
|
1294
|
+
query?: {
|
|
1295
|
+
id?: string;
|
|
1296
|
+
domain?: string;
|
|
1297
|
+
};
|
|
1298
|
+
header?: never;
|
|
1299
|
+
path?: never;
|
|
1300
|
+
cookie?: never;
|
|
1301
|
+
};
|
|
1302
|
+
requestBody?: never;
|
|
1303
|
+
responses: {
|
|
1304
|
+
/** @description MachineRecordV1 */
|
|
1305
|
+
200: {
|
|
1306
|
+
headers: {
|
|
1307
|
+
[name: string]: unknown;
|
|
1308
|
+
};
|
|
1309
|
+
content: {
|
|
1310
|
+
"application/json": components["schemas"]["MachineRecordV1"];
|
|
1311
|
+
};
|
|
1312
|
+
};
|
|
1313
|
+
/** @description no record */
|
|
1314
|
+
404: {
|
|
1315
|
+
headers: {
|
|
1316
|
+
[name: string]: unknown;
|
|
1317
|
+
};
|
|
1318
|
+
content?: never;
|
|
1319
|
+
};
|
|
1320
|
+
};
|
|
1321
|
+
};
|
|
1322
|
+
fixStaleCache: {
|
|
1323
|
+
parameters: {
|
|
1324
|
+
query?: {
|
|
1325
|
+
domain?: string;
|
|
1326
|
+
id?: string;
|
|
1327
|
+
};
|
|
1328
|
+
header?: never;
|
|
1329
|
+
path?: never;
|
|
1330
|
+
cookie?: never;
|
|
1331
|
+
};
|
|
1332
|
+
requestBody?: never;
|
|
1333
|
+
responses: {
|
|
1334
|
+
/** @description plan */
|
|
1335
|
+
200: {
|
|
1336
|
+
headers: {
|
|
1337
|
+
[name: string]: unknown;
|
|
1338
|
+
};
|
|
1339
|
+
content: {
|
|
1340
|
+
"application/json": unknown;
|
|
1341
|
+
};
|
|
1342
|
+
};
|
|
1343
|
+
/** @description no domain or id */
|
|
1344
|
+
400: {
|
|
1345
|
+
headers: {
|
|
1346
|
+
[name: string]: unknown;
|
|
1347
|
+
};
|
|
1348
|
+
content?: never;
|
|
1349
|
+
};
|
|
1350
|
+
/** @description unknown id */
|
|
1351
|
+
404: {
|
|
1352
|
+
headers: {
|
|
1353
|
+
[name: string]: unknown;
|
|
1354
|
+
};
|
|
1355
|
+
content?: never;
|
|
1356
|
+
};
|
|
1357
|
+
/** @description homepage did not answer */
|
|
1358
|
+
502: {
|
|
1359
|
+
headers: {
|
|
1360
|
+
[name: string]: unknown;
|
|
1361
|
+
};
|
|
1362
|
+
content?: never;
|
|
1363
|
+
};
|
|
1364
|
+
};
|
|
1365
|
+
};
|
|
1366
|
+
fixMachineChain: {
|
|
1367
|
+
parameters: {
|
|
1368
|
+
query?: {
|
|
1369
|
+
domain?: string;
|
|
1370
|
+
id?: string;
|
|
1371
|
+
};
|
|
1372
|
+
header?: never;
|
|
1373
|
+
path?: never;
|
|
1374
|
+
cookie?: never;
|
|
1375
|
+
};
|
|
1376
|
+
requestBody?: never;
|
|
1377
|
+
responses: {
|
|
1378
|
+
/** @description plan */
|
|
1379
|
+
200: {
|
|
1380
|
+
headers: {
|
|
1381
|
+
[name: string]: unknown;
|
|
1382
|
+
};
|
|
1383
|
+
content: {
|
|
1384
|
+
"application/json": unknown;
|
|
1385
|
+
};
|
|
1386
|
+
};
|
|
1387
|
+
/** @description no domain or id */
|
|
1388
|
+
400: {
|
|
1389
|
+
headers: {
|
|
1390
|
+
[name: string]: unknown;
|
|
1391
|
+
};
|
|
1392
|
+
content?: never;
|
|
1393
|
+
};
|
|
1394
|
+
/** @description no scan on file */
|
|
1395
|
+
404: {
|
|
1396
|
+
headers: {
|
|
1397
|
+
[name: string]: unknown;
|
|
1398
|
+
};
|
|
1399
|
+
content?: never;
|
|
1400
|
+
};
|
|
1401
|
+
};
|
|
1402
|
+
};
|
|
1403
|
+
fixMostlyCode: {
|
|
1404
|
+
parameters: {
|
|
1405
|
+
query?: {
|
|
1406
|
+
domain?: string;
|
|
1407
|
+
id?: string;
|
|
1408
|
+
};
|
|
1409
|
+
header?: never;
|
|
1410
|
+
path?: never;
|
|
1411
|
+
cookie?: never;
|
|
1412
|
+
};
|
|
1413
|
+
requestBody?: never;
|
|
1414
|
+
responses: {
|
|
1415
|
+
/** @description plan */
|
|
1416
|
+
200: {
|
|
1417
|
+
headers: {
|
|
1418
|
+
[name: string]: unknown;
|
|
1419
|
+
};
|
|
1420
|
+
content: {
|
|
1421
|
+
"application/json": unknown;
|
|
1422
|
+
};
|
|
1423
|
+
};
|
|
1424
|
+
/** @description no domain or id */
|
|
1425
|
+
400: {
|
|
1426
|
+
headers: {
|
|
1427
|
+
[name: string]: unknown;
|
|
1428
|
+
};
|
|
1429
|
+
content?: never;
|
|
1430
|
+
};
|
|
1431
|
+
/** @description homepage did not answer 200 */
|
|
1432
|
+
502: {
|
|
1433
|
+
headers: {
|
|
1434
|
+
[name: string]: unknown;
|
|
1435
|
+
};
|
|
1436
|
+
content?: never;
|
|
1437
|
+
};
|
|
1438
|
+
};
|
|
1439
|
+
};
|
|
1440
|
+
getCorroboration: {
|
|
1441
|
+
parameters: {
|
|
1442
|
+
query?: {
|
|
1443
|
+
domain?: string;
|
|
1444
|
+
id?: string;
|
|
1445
|
+
};
|
|
1446
|
+
header?: never;
|
|
1447
|
+
path?: never;
|
|
1448
|
+
cookie?: never;
|
|
1449
|
+
};
|
|
1450
|
+
requestBody?: never;
|
|
1451
|
+
responses: {
|
|
1452
|
+
/** @description corroboration */
|
|
1453
|
+
200: {
|
|
1454
|
+
headers: {
|
|
1455
|
+
[name: string]: unknown;
|
|
1456
|
+
};
|
|
1457
|
+
content: {
|
|
1458
|
+
"application/json": unknown;
|
|
1459
|
+
};
|
|
1460
|
+
};
|
|
1461
|
+
/** @description no record */
|
|
1462
|
+
404: {
|
|
1463
|
+
headers: {
|
|
1464
|
+
[name: string]: unknown;
|
|
1465
|
+
};
|
|
1466
|
+
content?: never;
|
|
1467
|
+
};
|
|
1468
|
+
};
|
|
1469
|
+
};
|
|
1470
|
+
explainFinding: {
|
|
1471
|
+
parameters: {
|
|
1472
|
+
query?: {
|
|
1473
|
+
id?: string;
|
|
1474
|
+
domain?: string;
|
|
1475
|
+
code?: string;
|
|
1476
|
+
path?: string;
|
|
1477
|
+
};
|
|
1478
|
+
header?: never;
|
|
1479
|
+
path?: never;
|
|
1480
|
+
cookie?: never;
|
|
1481
|
+
};
|
|
1482
|
+
requestBody?: never;
|
|
1483
|
+
responses: {
|
|
1484
|
+
/** @description explanation */
|
|
1485
|
+
200: {
|
|
1486
|
+
headers: {
|
|
1487
|
+
[name: string]: unknown;
|
|
1488
|
+
};
|
|
1489
|
+
content: {
|
|
1490
|
+
"application/json": unknown;
|
|
1491
|
+
};
|
|
1492
|
+
};
|
|
1493
|
+
/** @description locked: needs a licence for the domain */
|
|
1494
|
+
403: {
|
|
1495
|
+
headers: {
|
|
1496
|
+
[name: string]: unknown;
|
|
1497
|
+
};
|
|
1498
|
+
content?: never;
|
|
1499
|
+
};
|
|
1500
|
+
/** @description no record or finding */
|
|
1501
|
+
404: {
|
|
1502
|
+
headers: {
|
|
1503
|
+
[name: string]: unknown;
|
|
1504
|
+
};
|
|
1505
|
+
content?: never;
|
|
1506
|
+
};
|
|
1507
|
+
};
|
|
1508
|
+
};
|
|
1509
|
+
listVerifiedCapabilities: {
|
|
1510
|
+
parameters: {
|
|
1511
|
+
query: {
|
|
1512
|
+
domain: string;
|
|
1513
|
+
verified?: "1";
|
|
1514
|
+
};
|
|
1515
|
+
header?: never;
|
|
1516
|
+
path?: never;
|
|
1517
|
+
cookie?: never;
|
|
1518
|
+
};
|
|
1519
|
+
requestBody?: never;
|
|
1520
|
+
responses: {
|
|
1521
|
+
/** @description capabilities */
|
|
1522
|
+
200: {
|
|
1523
|
+
headers: {
|
|
1524
|
+
[name: string]: unknown;
|
|
1525
|
+
};
|
|
1526
|
+
content: {
|
|
1527
|
+
"application/json": unknown;
|
|
1528
|
+
};
|
|
1529
|
+
};
|
|
1530
|
+
/** @description no record */
|
|
1531
|
+
404: {
|
|
1532
|
+
headers: {
|
|
1533
|
+
[name: string]: unknown;
|
|
1534
|
+
};
|
|
1535
|
+
content?: never;
|
|
1536
|
+
};
|
|
1537
|
+
};
|
|
1538
|
+
};
|
|
1539
|
+
getReportV1: {
|
|
1540
|
+
parameters: {
|
|
1541
|
+
query?: never;
|
|
1542
|
+
header: {
|
|
1543
|
+
"x-crawlcheck-key": string;
|
|
1544
|
+
};
|
|
1545
|
+
path: {
|
|
1546
|
+
id: string;
|
|
1547
|
+
};
|
|
1548
|
+
cookie?: never;
|
|
1549
|
+
};
|
|
1550
|
+
requestBody?: never;
|
|
1551
|
+
responses: {
|
|
1552
|
+
/** @description PublicReportV1 */
|
|
1553
|
+
200: {
|
|
1554
|
+
headers: {
|
|
1555
|
+
[name: string]: unknown;
|
|
1556
|
+
};
|
|
1557
|
+
content: {
|
|
1558
|
+
"application/json": components["schemas"]["PublicReportV1"];
|
|
1559
|
+
};
|
|
1560
|
+
};
|
|
1561
|
+
/** @description ErrorV1: unauthorised */
|
|
1562
|
+
401: {
|
|
1563
|
+
headers: {
|
|
1564
|
+
[name: string]: unknown;
|
|
1565
|
+
};
|
|
1566
|
+
content?: never;
|
|
1567
|
+
};
|
|
1568
|
+
/** @description ErrorV1: not_found */
|
|
1569
|
+
404: {
|
|
1570
|
+
headers: {
|
|
1571
|
+
[name: string]: unknown;
|
|
1572
|
+
};
|
|
1573
|
+
content?: never;
|
|
1574
|
+
};
|
|
1575
|
+
};
|
|
1576
|
+
};
|
|
1577
|
+
locateFacts: {
|
|
1578
|
+
parameters: {
|
|
1579
|
+
query?: {
|
|
1580
|
+
id?: string;
|
|
1581
|
+
domain?: string;
|
|
1582
|
+
/** @description one fact, e.g. title or telephone */
|
|
1583
|
+
field?: string;
|
|
1584
|
+
/** @description a finding code; without a licence only the top finding */
|
|
1585
|
+
finding?: string;
|
|
1586
|
+
/** @description name, phone, locality, experience or all: both sides of a claim (what the structured data asserts, where the visible page says it) cut from the stored page, plus the rule that judged it, the inputs it read, the row it decided, and that rule rerun over the stored page (replay.reproduces); points per row with a licence or the owner's session */
|
|
1587
|
+
claim?: string;
|
|
1588
|
+
};
|
|
1589
|
+
header?: never;
|
|
1590
|
+
path?: never;
|
|
1591
|
+
cookie?: never;
|
|
1592
|
+
};
|
|
1593
|
+
requestBody?: never;
|
|
1594
|
+
responses: {
|
|
1595
|
+
/** @description locators read back */
|
|
1596
|
+
200: {
|
|
1597
|
+
headers: {
|
|
1598
|
+
[name: string]: unknown;
|
|
1599
|
+
};
|
|
1600
|
+
content: {
|
|
1601
|
+
"application/json": unknown;
|
|
1602
|
+
};
|
|
1603
|
+
};
|
|
1604
|
+
/** @description no locators or no stored page on this record */
|
|
1605
|
+
422: {
|
|
1606
|
+
headers: {
|
|
1607
|
+
[name: string]: unknown;
|
|
1608
|
+
};
|
|
1609
|
+
content?: never;
|
|
1610
|
+
};
|
|
1611
|
+
};
|
|
1612
|
+
};
|
|
1613
|
+
conformanceIndex: {
|
|
1614
|
+
parameters: {
|
|
1615
|
+
query?: never;
|
|
1616
|
+
header?: never;
|
|
1617
|
+
path?: never;
|
|
1618
|
+
cookie?: never;
|
|
1619
|
+
};
|
|
1620
|
+
requestBody?: never;
|
|
1621
|
+
responses: {
|
|
1622
|
+
/** @description index of fixtures with expected outputs */
|
|
1623
|
+
200: {
|
|
1624
|
+
headers: {
|
|
1625
|
+
[name: string]: unknown;
|
|
1626
|
+
};
|
|
1627
|
+
content: {
|
|
1628
|
+
"application/json": unknown;
|
|
1629
|
+
};
|
|
1630
|
+
};
|
|
1631
|
+
};
|
|
1632
|
+
};
|
|
1633
|
+
getReceipt: {
|
|
1634
|
+
parameters: {
|
|
1635
|
+
query: {
|
|
1636
|
+
id: string;
|
|
1637
|
+
download?: string;
|
|
1638
|
+
};
|
|
1639
|
+
header?: never;
|
|
1640
|
+
path?: never;
|
|
1641
|
+
cookie?: never;
|
|
1642
|
+
};
|
|
1643
|
+
requestBody?: never;
|
|
1644
|
+
responses: {
|
|
1645
|
+
/** @description receipt + verification */
|
|
1646
|
+
200: {
|
|
1647
|
+
headers: {
|
|
1648
|
+
[name: string]: unknown;
|
|
1649
|
+
};
|
|
1650
|
+
content: {
|
|
1651
|
+
"application/json": {
|
|
1652
|
+
ok: boolean;
|
|
1653
|
+
receipt: components["schemas"]["RemediationReceiptV1"];
|
|
1654
|
+
verification: Record<string, never>;
|
|
1655
|
+
offline?: Record<string, never>;
|
|
1656
|
+
};
|
|
1657
|
+
};
|
|
1658
|
+
};
|
|
1659
|
+
/** @description unknown id */
|
|
1660
|
+
404: {
|
|
1661
|
+
headers: {
|
|
1662
|
+
[name: string]: unknown;
|
|
1663
|
+
};
|
|
1664
|
+
content?: never;
|
|
1665
|
+
};
|
|
1666
|
+
};
|
|
1667
|
+
};
|
|
1668
|
+
verifyReceipt: {
|
|
1669
|
+
parameters: {
|
|
1670
|
+
query?: never;
|
|
1671
|
+
header?: never;
|
|
1672
|
+
path?: never;
|
|
1673
|
+
cookie?: never;
|
|
1674
|
+
};
|
|
1675
|
+
requestBody: {
|
|
1676
|
+
content: {
|
|
1677
|
+
"application/json": components["schemas"]["RemediationReceiptV1"];
|
|
1678
|
+
};
|
|
1679
|
+
};
|
|
1680
|
+
responses: {
|
|
1681
|
+
/** @description checks */
|
|
1682
|
+
200: {
|
|
1683
|
+
headers: {
|
|
1684
|
+
[name: string]: unknown;
|
|
1685
|
+
};
|
|
1686
|
+
content: {
|
|
1687
|
+
"application/json": {
|
|
1688
|
+
kind?: string;
|
|
1689
|
+
ok?: boolean;
|
|
1690
|
+
receipt_id?: string | null;
|
|
1691
|
+
checks?: {
|
|
1692
|
+
id?: string;
|
|
1693
|
+
ok?: boolean | null;
|
|
1694
|
+
why?: string;
|
|
1695
|
+
}[];
|
|
1696
|
+
};
|
|
1697
|
+
};
|
|
1698
|
+
};
|
|
1699
|
+
};
|
|
1700
|
+
};
|
|
1701
|
+
listReceipts: {
|
|
1702
|
+
parameters: {
|
|
1703
|
+
query: {
|
|
1704
|
+
domain: string;
|
|
1705
|
+
};
|
|
1706
|
+
header?: never;
|
|
1707
|
+
path?: never;
|
|
1708
|
+
cookie?: never;
|
|
1709
|
+
};
|
|
1710
|
+
requestBody?: never;
|
|
1711
|
+
responses: {
|
|
1712
|
+
/** @description receipts */
|
|
1713
|
+
200: {
|
|
1714
|
+
headers: {
|
|
1715
|
+
[name: string]: unknown;
|
|
1716
|
+
};
|
|
1717
|
+
content: {
|
|
1718
|
+
"application/json": unknown;
|
|
1719
|
+
};
|
|
1720
|
+
};
|
|
1721
|
+
/** @description no licence */
|
|
1722
|
+
403: {
|
|
1723
|
+
headers: {
|
|
1724
|
+
[name: string]: unknown;
|
|
1725
|
+
};
|
|
1726
|
+
content?: never;
|
|
1727
|
+
};
|
|
1728
|
+
};
|
|
1729
|
+
};
|
|
1730
|
+
verifyAndRollback: {
|
|
1731
|
+
parameters: {
|
|
1732
|
+
query?: {
|
|
1733
|
+
/** @description report id before the change */
|
|
1734
|
+
from?: string;
|
|
1735
|
+
/** @description report id after the change */
|
|
1736
|
+
to?: string;
|
|
1737
|
+
/** @description instead of from/to: the last re-measured fix for this domain */
|
|
1738
|
+
domain?: string;
|
|
1739
|
+
};
|
|
1740
|
+
header?: never;
|
|
1741
|
+
path?: never;
|
|
1742
|
+
cookie?: never;
|
|
1743
|
+
};
|
|
1744
|
+
requestBody?: never;
|
|
1745
|
+
responses: {
|
|
1746
|
+
/** @description verification */
|
|
1747
|
+
200: {
|
|
1748
|
+
headers: {
|
|
1749
|
+
[name: string]: unknown;
|
|
1750
|
+
};
|
|
1751
|
+
content: {
|
|
1752
|
+
"application/json": unknown;
|
|
1753
|
+
};
|
|
1754
|
+
};
|
|
1755
|
+
/** @description no pair of records named */
|
|
1756
|
+
400: {
|
|
1757
|
+
headers: {
|
|
1758
|
+
[name: string]: unknown;
|
|
1759
|
+
};
|
|
1760
|
+
content?: never;
|
|
1761
|
+
};
|
|
1762
|
+
/** @description needs a licence or the owner's session */
|
|
1763
|
+
403: {
|
|
1764
|
+
headers: {
|
|
1765
|
+
[name: string]: unknown;
|
|
1766
|
+
};
|
|
1767
|
+
content?: never;
|
|
1768
|
+
};
|
|
1769
|
+
/** @description the two records cannot be compared (different domains, or the order is reversed) */
|
|
1770
|
+
422: {
|
|
1771
|
+
headers: {
|
|
1772
|
+
[name: string]: unknown;
|
|
1773
|
+
};
|
|
1774
|
+
content?: never;
|
|
1775
|
+
};
|
|
1776
|
+
};
|
|
1777
|
+
};
|
|
1778
|
+
rollbackFile: {
|
|
1779
|
+
parameters: {
|
|
1780
|
+
query: {
|
|
1781
|
+
id: string;
|
|
1782
|
+
/** @description e.g. /robots.txt */
|
|
1783
|
+
path: string;
|
|
1784
|
+
};
|
|
1785
|
+
header?: never;
|
|
1786
|
+
path?: never;
|
|
1787
|
+
cookie?: never;
|
|
1788
|
+
};
|
|
1789
|
+
requestBody?: never;
|
|
1790
|
+
responses: {
|
|
1791
|
+
/** @description the file; x-crawlcheck-sha256 carries its hash */
|
|
1792
|
+
200: {
|
|
1793
|
+
headers: {
|
|
1794
|
+
[name: string]: unknown;
|
|
1795
|
+
};
|
|
1796
|
+
content: {
|
|
1797
|
+
"text/plain": unknown;
|
|
1798
|
+
};
|
|
1799
|
+
};
|
|
1800
|
+
/** @description needs a licence or the owner's session */
|
|
1801
|
+
403: {
|
|
1802
|
+
headers: {
|
|
1803
|
+
[name: string]: unknown;
|
|
1804
|
+
};
|
|
1805
|
+
content?: never;
|
|
1806
|
+
};
|
|
1807
|
+
/** @description no file at that path in the record, or the bytes were not kept */
|
|
1808
|
+
404: {
|
|
1809
|
+
headers: {
|
|
1810
|
+
[name: string]: unknown;
|
|
1811
|
+
};
|
|
1812
|
+
content?: never;
|
|
1813
|
+
};
|
|
1814
|
+
};
|
|
1815
|
+
};
|
|
1816
|
+
fixImpact: {
|
|
1817
|
+
parameters: {
|
|
1818
|
+
query?: {
|
|
1819
|
+
id?: string;
|
|
1820
|
+
domain?: string;
|
|
1821
|
+
/** @description comma-separated fix ids; applied together */
|
|
1822
|
+
fix?: string;
|
|
1823
|
+
};
|
|
1824
|
+
header?: never;
|
|
1825
|
+
path?: never;
|
|
1826
|
+
cookie?: never;
|
|
1827
|
+
};
|
|
1828
|
+
requestBody?: never;
|
|
1829
|
+
responses: {
|
|
1830
|
+
/** @description fix impact */
|
|
1831
|
+
200: {
|
|
1832
|
+
headers: {
|
|
1833
|
+
[name: string]: unknown;
|
|
1834
|
+
};
|
|
1835
|
+
content: {
|
|
1836
|
+
"application/json": unknown;
|
|
1837
|
+
};
|
|
1838
|
+
};
|
|
1839
|
+
/** @description needs a licence or the owner's session */
|
|
1840
|
+
403: {
|
|
1841
|
+
headers: {
|
|
1842
|
+
[name: string]: unknown;
|
|
1843
|
+
};
|
|
1844
|
+
content?: never;
|
|
1845
|
+
};
|
|
1846
|
+
/** @description no record */
|
|
1847
|
+
404: {
|
|
1848
|
+
headers: {
|
|
1849
|
+
[name: string]: unknown;
|
|
1850
|
+
};
|
|
1851
|
+
content?: never;
|
|
1852
|
+
};
|
|
1853
|
+
};
|
|
1854
|
+
};
|
|
1855
|
+
fixImpactPost: {
|
|
1856
|
+
parameters: {
|
|
1857
|
+
query?: never;
|
|
1858
|
+
header?: never;
|
|
1859
|
+
path?: never;
|
|
1860
|
+
cookie?: never;
|
|
1861
|
+
};
|
|
1862
|
+
requestBody: {
|
|
1863
|
+
content: {
|
|
1864
|
+
"application/json": {
|
|
1865
|
+
id?: string;
|
|
1866
|
+
domain?: string;
|
|
1867
|
+
fix?: string[];
|
|
1868
|
+
};
|
|
1869
|
+
};
|
|
1870
|
+
};
|
|
1871
|
+
responses: {
|
|
1872
|
+
/** @description fix impact */
|
|
1873
|
+
200: {
|
|
1874
|
+
headers: {
|
|
1875
|
+
[name: string]: unknown;
|
|
1876
|
+
};
|
|
1877
|
+
content: {
|
|
1878
|
+
"application/json": unknown;
|
|
1879
|
+
};
|
|
1880
|
+
};
|
|
1881
|
+
/** @description needs a licence or the owner's session */
|
|
1882
|
+
403: {
|
|
1883
|
+
headers: {
|
|
1884
|
+
[name: string]: unknown;
|
|
1885
|
+
};
|
|
1886
|
+
content?: never;
|
|
1887
|
+
};
|
|
1888
|
+
};
|
|
1889
|
+
};
|
|
1890
|
+
whatIf: {
|
|
1891
|
+
parameters: {
|
|
1892
|
+
query?: {
|
|
1893
|
+
id?: string;
|
|
1894
|
+
domain?: string;
|
|
1895
|
+
/** @description comma-separated finding codes or d1: ids */
|
|
1896
|
+
clear?: string;
|
|
1897
|
+
};
|
|
1898
|
+
header?: never;
|
|
1899
|
+
path?: never;
|
|
1900
|
+
cookie?: never;
|
|
1901
|
+
};
|
|
1902
|
+
requestBody?: never;
|
|
1903
|
+
responses: {
|
|
1904
|
+
/** @description what-if */
|
|
1905
|
+
200: {
|
|
1906
|
+
headers: {
|
|
1907
|
+
[name: string]: unknown;
|
|
1908
|
+
};
|
|
1909
|
+
content: {
|
|
1910
|
+
"application/json": unknown;
|
|
1911
|
+
};
|
|
1912
|
+
};
|
|
1913
|
+
/** @description needs a licence or the owner's session */
|
|
1914
|
+
403: {
|
|
1915
|
+
headers: {
|
|
1916
|
+
[name: string]: unknown;
|
|
1917
|
+
};
|
|
1918
|
+
content?: never;
|
|
1919
|
+
};
|
|
1920
|
+
/** @description no record */
|
|
1921
|
+
404: {
|
|
1922
|
+
headers: {
|
|
1923
|
+
[name: string]: unknown;
|
|
1924
|
+
};
|
|
1925
|
+
content?: never;
|
|
1926
|
+
};
|
|
1927
|
+
};
|
|
1928
|
+
};
|
|
1929
|
+
whatIfPost: {
|
|
1930
|
+
parameters: {
|
|
1931
|
+
query?: never;
|
|
1932
|
+
header?: never;
|
|
1933
|
+
path?: never;
|
|
1934
|
+
cookie?: never;
|
|
1935
|
+
};
|
|
1936
|
+
requestBody: {
|
|
1937
|
+
content: {
|
|
1938
|
+
"application/json": {
|
|
1939
|
+
id?: string;
|
|
1940
|
+
domain?: string;
|
|
1941
|
+
fix?: {
|
|
1942
|
+
section_id?: string;
|
|
1943
|
+
row?: string;
|
|
1944
|
+
}[];
|
|
1945
|
+
clear?: string[];
|
|
1946
|
+
};
|
|
1947
|
+
};
|
|
1948
|
+
};
|
|
1949
|
+
responses: {
|
|
1950
|
+
/** @description what-if */
|
|
1951
|
+
200: {
|
|
1952
|
+
headers: {
|
|
1953
|
+
[name: string]: unknown;
|
|
1954
|
+
};
|
|
1955
|
+
content: {
|
|
1956
|
+
"application/json": unknown;
|
|
1957
|
+
};
|
|
1958
|
+
};
|
|
1959
|
+
/** @description needs a licence or the owner's session */
|
|
1960
|
+
403: {
|
|
1961
|
+
headers: {
|
|
1962
|
+
[name: string]: unknown;
|
|
1963
|
+
};
|
|
1964
|
+
content?: never;
|
|
1965
|
+
};
|
|
1966
|
+
};
|
|
1967
|
+
};
|
|
1968
|
+
getMachineExperienceRecordSchema: {
|
|
1969
|
+
parameters: {
|
|
1970
|
+
query?: never;
|
|
1971
|
+
header?: never;
|
|
1972
|
+
path?: never;
|
|
1973
|
+
cookie?: never;
|
|
1974
|
+
};
|
|
1975
|
+
requestBody?: never;
|
|
1976
|
+
responses: {
|
|
1977
|
+
/** @description application/schema+json */
|
|
1978
|
+
200: {
|
|
1979
|
+
headers: {
|
|
1980
|
+
[name: string]: unknown;
|
|
1981
|
+
};
|
|
1982
|
+
content: {
|
|
1983
|
+
"application/json": unknown;
|
|
1984
|
+
};
|
|
1985
|
+
};
|
|
1986
|
+
};
|
|
1987
|
+
};
|
|
1988
|
+
getSchemaV1: {
|
|
1989
|
+
parameters: {
|
|
1990
|
+
query?: never;
|
|
1991
|
+
header?: never;
|
|
1992
|
+
path?: never;
|
|
1993
|
+
cookie?: never;
|
|
1994
|
+
};
|
|
1995
|
+
requestBody?: never;
|
|
1996
|
+
responses: {
|
|
1997
|
+
/** @description JSON Schema 2020-12 */
|
|
1998
|
+
200: {
|
|
1999
|
+
headers: {
|
|
2000
|
+
[name: string]: unknown;
|
|
2001
|
+
};
|
|
2002
|
+
content: {
|
|
2003
|
+
"application/json": unknown;
|
|
2004
|
+
};
|
|
2005
|
+
};
|
|
2006
|
+
};
|
|
2007
|
+
};
|
|
2008
|
+
listApiKeys: {
|
|
2009
|
+
parameters: {
|
|
2010
|
+
query?: never;
|
|
2011
|
+
header: {
|
|
2012
|
+
"x-crawlcheck-key": string;
|
|
2013
|
+
};
|
|
2014
|
+
path?: never;
|
|
2015
|
+
cookie?: never;
|
|
2016
|
+
};
|
|
2017
|
+
requestBody?: never;
|
|
2018
|
+
responses: {
|
|
2019
|
+
/** @description keys[] */
|
|
2020
|
+
200: {
|
|
2021
|
+
headers: {
|
|
2022
|
+
[name: string]: unknown;
|
|
2023
|
+
};
|
|
2024
|
+
content: {
|
|
2025
|
+
"application/json": unknown;
|
|
2026
|
+
};
|
|
2027
|
+
};
|
|
2028
|
+
/** @description No valid licence key */
|
|
2029
|
+
401: {
|
|
2030
|
+
headers: {
|
|
2031
|
+
[name: string]: unknown;
|
|
2032
|
+
};
|
|
2033
|
+
content?: never;
|
|
2034
|
+
};
|
|
2035
|
+
};
|
|
2036
|
+
};
|
|
2037
|
+
createApiKey: {
|
|
2038
|
+
parameters: {
|
|
2039
|
+
query?: never;
|
|
2040
|
+
header: {
|
|
2041
|
+
"x-crawlcheck-key": string;
|
|
2042
|
+
};
|
|
2043
|
+
path?: never;
|
|
2044
|
+
cookie?: never;
|
|
2045
|
+
};
|
|
2046
|
+
requestBody: {
|
|
2047
|
+
content: {
|
|
2048
|
+
"application/json": {
|
|
2049
|
+
name?: string;
|
|
2050
|
+
scopes?: ("scan" | "read" | "share")[];
|
|
2051
|
+
domains?: string[];
|
|
2052
|
+
days?: number;
|
|
2053
|
+
};
|
|
2054
|
+
};
|
|
2055
|
+
};
|
|
2056
|
+
responses: {
|
|
2057
|
+
/** @description key, id, scopes, domains, expires */
|
|
2058
|
+
201: {
|
|
2059
|
+
headers: {
|
|
2060
|
+
[name: string]: unknown;
|
|
2061
|
+
};
|
|
2062
|
+
content: {
|
|
2063
|
+
"application/json": unknown;
|
|
2064
|
+
};
|
|
2065
|
+
};
|
|
2066
|
+
/** @description No usable scope */
|
|
2067
|
+
400: {
|
|
2068
|
+
headers: {
|
|
2069
|
+
[name: string]: unknown;
|
|
2070
|
+
};
|
|
2071
|
+
content?: never;
|
|
2072
|
+
};
|
|
2073
|
+
/** @description No valid licence key */
|
|
2074
|
+
401: {
|
|
2075
|
+
headers: {
|
|
2076
|
+
[name: string]: unknown;
|
|
2077
|
+
};
|
|
2078
|
+
content?: never;
|
|
2079
|
+
};
|
|
2080
|
+
/** @description Domain not on the licence */
|
|
2081
|
+
403: {
|
|
2082
|
+
headers: {
|
|
2083
|
+
[name: string]: unknown;
|
|
2084
|
+
};
|
|
2085
|
+
content?: never;
|
|
2086
|
+
};
|
|
2087
|
+
/** @description Twenty-key limit reached */
|
|
2088
|
+
409: {
|
|
2089
|
+
headers: {
|
|
2090
|
+
[name: string]: unknown;
|
|
2091
|
+
};
|
|
2092
|
+
content?: never;
|
|
2093
|
+
};
|
|
2094
|
+
};
|
|
2095
|
+
};
|
|
2096
|
+
revokeApiKey: {
|
|
2097
|
+
parameters: {
|
|
2098
|
+
query: {
|
|
2099
|
+
id: string;
|
|
2100
|
+
};
|
|
2101
|
+
header: {
|
|
2102
|
+
"x-crawlcheck-key": string;
|
|
2103
|
+
};
|
|
2104
|
+
path?: never;
|
|
2105
|
+
cookie?: never;
|
|
2106
|
+
};
|
|
2107
|
+
requestBody?: never;
|
|
2108
|
+
responses: {
|
|
2109
|
+
/** @description Revoked */
|
|
2110
|
+
200: {
|
|
2111
|
+
headers: {
|
|
2112
|
+
[name: string]: unknown;
|
|
2113
|
+
};
|
|
2114
|
+
content: {
|
|
2115
|
+
"application/json": unknown;
|
|
2116
|
+
};
|
|
2117
|
+
};
|
|
2118
|
+
/** @description No such key on this licence */
|
|
2119
|
+
404: {
|
|
2120
|
+
headers: {
|
|
2121
|
+
[name: string]: unknown;
|
|
2122
|
+
};
|
|
2123
|
+
content?: never;
|
|
2124
|
+
};
|
|
2125
|
+
};
|
|
2126
|
+
};
|
|
2127
|
+
createShareLink: {
|
|
2128
|
+
parameters: {
|
|
2129
|
+
query?: never;
|
|
2130
|
+
header: {
|
|
2131
|
+
"x-crawlcheck-key": string;
|
|
2132
|
+
};
|
|
2133
|
+
path?: never;
|
|
2134
|
+
cookie?: never;
|
|
2135
|
+
};
|
|
2136
|
+
requestBody: {
|
|
2137
|
+
content: {
|
|
2138
|
+
"application/json": {
|
|
2139
|
+
/** @description Report id, or a report URL */
|
|
2140
|
+
rid: string;
|
|
2141
|
+
/** @default 30 */
|
|
2142
|
+
days?: number;
|
|
2143
|
+
};
|
|
2144
|
+
};
|
|
2145
|
+
};
|
|
2146
|
+
responses: {
|
|
2147
|
+
/** @description url, rid, expires, revoke */
|
|
2148
|
+
200: {
|
|
2149
|
+
headers: {
|
|
2150
|
+
[name: string]: unknown;
|
|
2151
|
+
};
|
|
2152
|
+
content: {
|
|
2153
|
+
"application/json": unknown;
|
|
2154
|
+
};
|
|
2155
|
+
};
|
|
2156
|
+
/** @description No usable report id */
|
|
2157
|
+
400: {
|
|
2158
|
+
headers: {
|
|
2159
|
+
[name: string]: unknown;
|
|
2160
|
+
};
|
|
2161
|
+
content?: never;
|
|
2162
|
+
};
|
|
2163
|
+
/** @description No valid licence key */
|
|
2164
|
+
401: {
|
|
2165
|
+
headers: {
|
|
2166
|
+
[name: string]: unknown;
|
|
2167
|
+
};
|
|
2168
|
+
content?: never;
|
|
2169
|
+
};
|
|
2170
|
+
/** @description Report domain is not on this licence */
|
|
2171
|
+
403: {
|
|
2172
|
+
headers: {
|
|
2173
|
+
[name: string]: unknown;
|
|
2174
|
+
};
|
|
2175
|
+
content?: never;
|
|
2176
|
+
};
|
|
2177
|
+
/** @description No such report */
|
|
2178
|
+
404: {
|
|
2179
|
+
headers: {
|
|
2180
|
+
[name: string]: unknown;
|
|
2181
|
+
};
|
|
2182
|
+
content?: never;
|
|
2183
|
+
};
|
|
2184
|
+
};
|
|
2185
|
+
};
|
|
2186
|
+
revokeShareLink: {
|
|
2187
|
+
parameters: {
|
|
2188
|
+
query: {
|
|
2189
|
+
s: string;
|
|
2190
|
+
};
|
|
2191
|
+
header: {
|
|
2192
|
+
"x-crawlcheck-key": string;
|
|
2193
|
+
};
|
|
2194
|
+
path?: never;
|
|
2195
|
+
cookie?: never;
|
|
2196
|
+
};
|
|
2197
|
+
requestBody?: never;
|
|
2198
|
+
responses: {
|
|
2199
|
+
/** @description Revoked */
|
|
2200
|
+
200: {
|
|
2201
|
+
headers: {
|
|
2202
|
+
[name: string]: unknown;
|
|
2203
|
+
};
|
|
2204
|
+
content: {
|
|
2205
|
+
"application/json": unknown;
|
|
2206
|
+
};
|
|
2207
|
+
};
|
|
2208
|
+
/** @description No usable token */
|
|
2209
|
+
400: {
|
|
2210
|
+
headers: {
|
|
2211
|
+
[name: string]: unknown;
|
|
2212
|
+
};
|
|
2213
|
+
content?: never;
|
|
2214
|
+
};
|
|
2215
|
+
/** @description No valid licence key */
|
|
2216
|
+
401: {
|
|
2217
|
+
headers: {
|
|
2218
|
+
[name: string]: unknown;
|
|
2219
|
+
};
|
|
2220
|
+
content?: never;
|
|
2221
|
+
};
|
|
2222
|
+
/** @description No such token on this licence */
|
|
2223
|
+
404: {
|
|
2224
|
+
headers: {
|
|
2225
|
+
[name: string]: unknown;
|
|
2226
|
+
};
|
|
2227
|
+
content?: never;
|
|
2228
|
+
};
|
|
2229
|
+
};
|
|
2230
|
+
};
|
|
2231
|
+
scanDomainLicensed: {
|
|
2232
|
+
parameters: {
|
|
2233
|
+
query?: never;
|
|
2234
|
+
header: {
|
|
2235
|
+
"x-crawlcheck-key": string;
|
|
2236
|
+
};
|
|
2237
|
+
path?: never;
|
|
2238
|
+
cookie?: never;
|
|
2239
|
+
};
|
|
2240
|
+
requestBody: {
|
|
2241
|
+
content: {
|
|
2242
|
+
"application/json": {
|
|
2243
|
+
domain: string;
|
|
2244
|
+
};
|
|
2245
|
+
};
|
|
2246
|
+
};
|
|
2247
|
+
responses: {
|
|
2248
|
+
/** @description The scan record, identical to /api/scan */
|
|
2249
|
+
200: {
|
|
2250
|
+
headers: {
|
|
2251
|
+
[name: string]: unknown;
|
|
2252
|
+
};
|
|
2253
|
+
content: {
|
|
2254
|
+
"application/json": unknown;
|
|
2255
|
+
};
|
|
2256
|
+
};
|
|
2257
|
+
/** @description No valid licence key */
|
|
2258
|
+
404: {
|
|
2259
|
+
headers: {
|
|
2260
|
+
[name: string]: unknown;
|
|
2261
|
+
};
|
|
2262
|
+
content?: never;
|
|
2263
|
+
};
|
|
2264
|
+
/** @description Key allowance used for this ten-minute window */
|
|
2265
|
+
429: {
|
|
2266
|
+
headers: {
|
|
2267
|
+
[name: string]: unknown;
|
|
2268
|
+
};
|
|
2269
|
+
content?: never;
|
|
2270
|
+
};
|
|
2271
|
+
};
|
|
2272
|
+
};
|
|
2273
|
+
checkBotKeyDirectory: {
|
|
2274
|
+
parameters: {
|
|
2275
|
+
query: {
|
|
2276
|
+
/** @description The signing agent's host or https origin, e.g. crawlcheck.io */
|
|
2277
|
+
agent: string;
|
|
2278
|
+
};
|
|
2279
|
+
header?: never;
|
|
2280
|
+
path?: never;
|
|
2281
|
+
cookie?: never;
|
|
2282
|
+
};
|
|
2283
|
+
requestBody?: never;
|
|
2284
|
+
responses: {
|
|
2285
|
+
/** @description The directory audit, every step shown */
|
|
2286
|
+
200: {
|
|
2287
|
+
headers: {
|
|
2288
|
+
[name: string]: unknown;
|
|
2289
|
+
};
|
|
2290
|
+
content: {
|
|
2291
|
+
"application/json": unknown;
|
|
2292
|
+
};
|
|
2293
|
+
};
|
|
2294
|
+
/** @description No usable agent named */
|
|
2295
|
+
400: {
|
|
2296
|
+
headers: {
|
|
2297
|
+
[name: string]: unknown;
|
|
2298
|
+
};
|
|
2299
|
+
content?: never;
|
|
2300
|
+
};
|
|
2301
|
+
};
|
|
2302
|
+
};
|
|
2303
|
+
verifySignedBotRequest: {
|
|
2304
|
+
parameters: {
|
|
2305
|
+
query?: never;
|
|
2306
|
+
header?: never;
|
|
2307
|
+
path?: never;
|
|
2308
|
+
cookie?: never;
|
|
2309
|
+
};
|
|
2310
|
+
requestBody: {
|
|
2311
|
+
content: {
|
|
2312
|
+
"application/json": {
|
|
2313
|
+
/** @description Pasted request headers: Host, Signature-Agent, Signature-Input, Signature, optionally the request line */
|
|
2314
|
+
request?: string;
|
|
2315
|
+
/** @description Alternatively, only the agent whose directory to audit */
|
|
2316
|
+
agent?: string;
|
|
2317
|
+
};
|
|
2318
|
+
};
|
|
2319
|
+
};
|
|
2320
|
+
responses: {
|
|
2321
|
+
/** @description The verdict with every step shown */
|
|
2322
|
+
200: {
|
|
2323
|
+
headers: {
|
|
2324
|
+
[name: string]: unknown;
|
|
2325
|
+
};
|
|
2326
|
+
content: {
|
|
2327
|
+
"application/json": unknown;
|
|
2328
|
+
};
|
|
2329
|
+
};
|
|
2330
|
+
/** @description Nothing to check */
|
|
2331
|
+
400: {
|
|
2332
|
+
headers: {
|
|
2333
|
+
[name: string]: unknown;
|
|
2334
|
+
};
|
|
2335
|
+
content?: never;
|
|
2336
|
+
};
|
|
2337
|
+
};
|
|
2338
|
+
};
|
|
2339
|
+
verifyCrawlerLog: {
|
|
2340
|
+
parameters: {
|
|
2341
|
+
query?: never;
|
|
2342
|
+
header?: never;
|
|
2343
|
+
path?: never;
|
|
2344
|
+
cookie?: never;
|
|
2345
|
+
};
|
|
2346
|
+
requestBody: {
|
|
2347
|
+
content: {
|
|
2348
|
+
"application/json": {
|
|
2349
|
+
/** @description Up to 200 raw log lines, 20 KB, newline separated */
|
|
2350
|
+
lines: string;
|
|
2351
|
+
};
|
|
2352
|
+
};
|
|
2353
|
+
};
|
|
2354
|
+
responses: {
|
|
2355
|
+
/** @description Per-line verdicts and a tally */
|
|
2356
|
+
200: {
|
|
2357
|
+
headers: {
|
|
2358
|
+
[name: string]: unknown;
|
|
2359
|
+
};
|
|
2360
|
+
content: {
|
|
2361
|
+
"application/json": components["schemas"]["VerifyResult"];
|
|
2362
|
+
};
|
|
2363
|
+
};
|
|
2364
|
+
/** @description No lines */
|
|
2365
|
+
400: {
|
|
2366
|
+
headers: {
|
|
2367
|
+
[name: string]: unknown;
|
|
2368
|
+
};
|
|
2369
|
+
content?: never;
|
|
2370
|
+
};
|
|
2371
|
+
};
|
|
2372
|
+
};
|
|
2373
|
+
depthCrawl: {
|
|
2374
|
+
parameters: {
|
|
2375
|
+
query?: never;
|
|
2376
|
+
header: {
|
|
2377
|
+
"x-crawlcheck-key": string;
|
|
2378
|
+
};
|
|
2379
|
+
path?: never;
|
|
2380
|
+
cookie?: never;
|
|
2381
|
+
};
|
|
2382
|
+
requestBody: {
|
|
2383
|
+
content: {
|
|
2384
|
+
"application/json": {
|
|
2385
|
+
domain: string;
|
|
2386
|
+
/** @description Page cap; above 300 runs as a job */
|
|
2387
|
+
pages?: number;
|
|
2388
|
+
};
|
|
2389
|
+
};
|
|
2390
|
+
};
|
|
2391
|
+
responses: {
|
|
2392
|
+
/** @description {id, state, pages, job, url}; poll /api/depth/{id} */
|
|
2393
|
+
202: {
|
|
2394
|
+
headers: {
|
|
2395
|
+
[name: string]: unknown;
|
|
2396
|
+
};
|
|
2397
|
+
content: {
|
|
2398
|
+
"application/json": unknown;
|
|
2399
|
+
};
|
|
2400
|
+
};
|
|
2401
|
+
/** @description No domain */
|
|
2402
|
+
400: {
|
|
2403
|
+
headers: {
|
|
2404
|
+
[name: string]: unknown;
|
|
2405
|
+
};
|
|
2406
|
+
content?: never;
|
|
2407
|
+
};
|
|
2408
|
+
/** @description No valid licence key */
|
|
2409
|
+
404: {
|
|
2410
|
+
headers: {
|
|
2411
|
+
[name: string]: unknown;
|
|
2412
|
+
};
|
|
2413
|
+
content?: never;
|
|
2414
|
+
};
|
|
2415
|
+
};
|
|
2416
|
+
};
|
|
2417
|
+
depthResult: {
|
|
2418
|
+
parameters: {
|
|
2419
|
+
query?: never;
|
|
2420
|
+
header?: never;
|
|
2421
|
+
path: {
|
|
2422
|
+
id: string;
|
|
2423
|
+
};
|
|
2424
|
+
cookie?: never;
|
|
2425
|
+
};
|
|
2426
|
+
requestBody?: never;
|
|
2427
|
+
responses: {
|
|
2428
|
+
/** @description JSON */
|
|
2429
|
+
200: {
|
|
2430
|
+
headers: {
|
|
2431
|
+
[name: string]: unknown;
|
|
2432
|
+
};
|
|
2433
|
+
content: {
|
|
2434
|
+
"application/json": Record<string, never>;
|
|
2435
|
+
};
|
|
2436
|
+
};
|
|
2437
|
+
/** @description Unknown id */
|
|
2438
|
+
404: {
|
|
2439
|
+
headers: {
|
|
2440
|
+
[name: string]: unknown;
|
|
2441
|
+
};
|
|
2442
|
+
content?: never;
|
|
2443
|
+
};
|
|
2444
|
+
};
|
|
2445
|
+
};
|
|
2446
|
+
usage: {
|
|
2447
|
+
parameters: {
|
|
2448
|
+
query?: never;
|
|
2449
|
+
header: {
|
|
2450
|
+
"x-crawlcheck-key": string;
|
|
2451
|
+
};
|
|
2452
|
+
path?: never;
|
|
2453
|
+
cookie?: never;
|
|
2454
|
+
};
|
|
2455
|
+
requestBody?: never;
|
|
2456
|
+
responses: {
|
|
2457
|
+
/** @description {plan, month, used, limit, remaining, resets_at} */
|
|
2458
|
+
200: {
|
|
2459
|
+
headers: {
|
|
2460
|
+
[name: string]: unknown;
|
|
2461
|
+
};
|
|
2462
|
+
content: {
|
|
2463
|
+
"application/json": unknown;
|
|
2464
|
+
};
|
|
2465
|
+
};
|
|
2466
|
+
/** @description No valid licence key */
|
|
2467
|
+
404: {
|
|
2468
|
+
headers: {
|
|
2469
|
+
[name: string]: unknown;
|
|
2470
|
+
};
|
|
2471
|
+
content?: never;
|
|
2472
|
+
};
|
|
2473
|
+
};
|
|
2474
|
+
};
|
|
2475
|
+
verifyRecord: {
|
|
2476
|
+
parameters: {
|
|
2477
|
+
query: {
|
|
2478
|
+
/** @description report id, d1: decision id, f1: finding id, or manifest sha256 */
|
|
2479
|
+
id: string;
|
|
2480
|
+
};
|
|
2481
|
+
header?: never;
|
|
2482
|
+
path?: never;
|
|
2483
|
+
cookie?: never;
|
|
2484
|
+
};
|
|
2485
|
+
requestBody?: never;
|
|
2486
|
+
responses: {
|
|
2487
|
+
/** @description {ok, id, checks[{name, ok, why}], summary{passed, failed, unverifiable}} */
|
|
2488
|
+
200: {
|
|
2489
|
+
headers: {
|
|
2490
|
+
[name: string]: unknown;
|
|
2491
|
+
};
|
|
2492
|
+
content: {
|
|
2493
|
+
"application/json": unknown;
|
|
2494
|
+
};
|
|
2495
|
+
};
|
|
2496
|
+
/** @description No record for that id */
|
|
2497
|
+
404: {
|
|
2498
|
+
headers: {
|
|
2499
|
+
[name: string]: unknown;
|
|
2500
|
+
};
|
|
2501
|
+
content?: never;
|
|
2502
|
+
};
|
|
2503
|
+
};
|
|
2504
|
+
};
|
|
2505
|
+
evidenceBundle: {
|
|
2506
|
+
parameters: {
|
|
2507
|
+
query: {
|
|
2508
|
+
/** @description report id, d1: decision id, f1: finding id, or manifest sha256 */
|
|
2509
|
+
id: string;
|
|
2510
|
+
/** @description 0 to return inline instead of as an attachment */
|
|
2511
|
+
download?: "0";
|
|
2512
|
+
};
|
|
2513
|
+
header?: never;
|
|
2514
|
+
path?: never;
|
|
2515
|
+
cookie?: never;
|
|
2516
|
+
};
|
|
2517
|
+
requestBody?: never;
|
|
2518
|
+
responses: {
|
|
2519
|
+
/** @description {kind, version, report, verifier, manifest, record, seal} */
|
|
2520
|
+
200: {
|
|
2521
|
+
headers: {
|
|
2522
|
+
[name: string]: unknown;
|
|
2523
|
+
};
|
|
2524
|
+
content: {
|
|
2525
|
+
"application/json": components["schemas"]["EvidenceBundleV1"];
|
|
2526
|
+
};
|
|
2527
|
+
};
|
|
2528
|
+
/** @description No record for that id */
|
|
2529
|
+
404: {
|
|
2530
|
+
headers: {
|
|
2531
|
+
[name: string]: unknown;
|
|
2532
|
+
};
|
|
2533
|
+
content?: never;
|
|
2534
|
+
};
|
|
2535
|
+
};
|
|
2536
|
+
};
|
|
2537
|
+
reconstructionTest: {
|
|
2538
|
+
parameters: {
|
|
2539
|
+
query?: never;
|
|
2540
|
+
header?: never;
|
|
2541
|
+
path?: never;
|
|
2542
|
+
cookie?: never;
|
|
2543
|
+
};
|
|
2544
|
+
requestBody?: never;
|
|
2545
|
+
responses: {
|
|
2546
|
+
/** @description records, identical, mismatched, per-record parts and the first difference of any mismatch */
|
|
2547
|
+
200: {
|
|
2548
|
+
headers: {
|
|
2549
|
+
[name: string]: unknown;
|
|
2550
|
+
};
|
|
2551
|
+
content: {
|
|
2552
|
+
"application/json": unknown;
|
|
2553
|
+
};
|
|
2554
|
+
};
|
|
2555
|
+
/** @description not run yet */
|
|
2556
|
+
404: {
|
|
2557
|
+
headers: {
|
|
2558
|
+
[name: string]: unknown;
|
|
2559
|
+
};
|
|
2560
|
+
content?: never;
|
|
2561
|
+
};
|
|
2562
|
+
};
|
|
2563
|
+
};
|
|
2564
|
+
graphResolve: {
|
|
2565
|
+
parameters: {
|
|
2566
|
+
query?: never;
|
|
2567
|
+
header: {
|
|
2568
|
+
"x-crawlcheck-key": string;
|
|
2569
|
+
};
|
|
2570
|
+
path: {
|
|
2571
|
+
id: string;
|
|
2572
|
+
};
|
|
2573
|
+
cookie?: never;
|
|
2574
|
+
};
|
|
2575
|
+
requestBody?: never;
|
|
2576
|
+
responses: {
|
|
2577
|
+
/** @description {ok, id, type, …} */
|
|
2578
|
+
200: {
|
|
2579
|
+
headers: {
|
|
2580
|
+
[name: string]: unknown;
|
|
2581
|
+
};
|
|
2582
|
+
content: {
|
|
2583
|
+
"application/json": unknown;
|
|
2584
|
+
};
|
|
2585
|
+
};
|
|
2586
|
+
/** @description Unknown id or no licence */
|
|
2587
|
+
404: {
|
|
2588
|
+
headers: {
|
|
2589
|
+
[name: string]: unknown;
|
|
2590
|
+
};
|
|
2591
|
+
content?: never;
|
|
2592
|
+
};
|
|
2593
|
+
};
|
|
2594
|
+
};
|
|
2595
|
+
batchSubmit: {
|
|
2596
|
+
parameters: {
|
|
2597
|
+
query?: never;
|
|
2598
|
+
header: {
|
|
2599
|
+
"x-crawlcheck-key": string;
|
|
2600
|
+
};
|
|
2601
|
+
path?: never;
|
|
2602
|
+
cookie?: never;
|
|
2603
|
+
};
|
|
2604
|
+
requestBody: {
|
|
2605
|
+
content: {
|
|
2606
|
+
"application/json": {
|
|
2607
|
+
domains: string[];
|
|
2608
|
+
/**
|
|
2609
|
+
* Format: uri
|
|
2610
|
+
* @description https; receives batch.done signed x-crawlcheck-signature: sha256=HMAC-SHA256(key, body)
|
|
2611
|
+
*/
|
|
2612
|
+
webhook?: string;
|
|
2613
|
+
};
|
|
2614
|
+
};
|
|
2615
|
+
};
|
|
2616
|
+
responses: {
|
|
2617
|
+
/** @description {id, state, counts, rejected, next_window, url} */
|
|
2618
|
+
202: {
|
|
2619
|
+
headers: {
|
|
2620
|
+
[name: string]: unknown;
|
|
2621
|
+
};
|
|
2622
|
+
content: {
|
|
2623
|
+
"application/json": unknown;
|
|
2624
|
+
};
|
|
2625
|
+
};
|
|
2626
|
+
/** @description No valid domains or bad webhook */
|
|
2627
|
+
400: {
|
|
2628
|
+
headers: {
|
|
2629
|
+
[name: string]: unknown;
|
|
2630
|
+
};
|
|
2631
|
+
content?: never;
|
|
2632
|
+
};
|
|
2633
|
+
/** @description No valid licence key */
|
|
2634
|
+
404: {
|
|
2635
|
+
headers: {
|
|
2636
|
+
[name: string]: unknown;
|
|
2637
|
+
};
|
|
2638
|
+
content?: never;
|
|
2639
|
+
};
|
|
2640
|
+
/** @description Over the per-batch limit */
|
|
2641
|
+
413: {
|
|
2642
|
+
headers: {
|
|
2643
|
+
[name: string]: unknown;
|
|
2644
|
+
};
|
|
2645
|
+
content?: never;
|
|
2646
|
+
};
|
|
2647
|
+
/** @description A batch is already running for this key */
|
|
2648
|
+
429: {
|
|
2649
|
+
headers: {
|
|
2650
|
+
[name: string]: unknown;
|
|
2651
|
+
};
|
|
2652
|
+
content?: never;
|
|
2653
|
+
};
|
|
2654
|
+
};
|
|
2655
|
+
};
|
|
2656
|
+
batchStatus: {
|
|
2657
|
+
parameters: {
|
|
2658
|
+
query?: never;
|
|
2659
|
+
header: {
|
|
2660
|
+
"x-crawlcheck-key": string;
|
|
2661
|
+
};
|
|
2662
|
+
path: {
|
|
2663
|
+
id: string;
|
|
2664
|
+
};
|
|
2665
|
+
cookie?: never;
|
|
2666
|
+
};
|
|
2667
|
+
requestBody?: never;
|
|
2668
|
+
responses: {
|
|
2669
|
+
/** @description JSON */
|
|
2670
|
+
200: {
|
|
2671
|
+
headers: {
|
|
2672
|
+
[name: string]: unknown;
|
|
2673
|
+
};
|
|
2674
|
+
content: {
|
|
2675
|
+
"application/json": unknown;
|
|
2676
|
+
};
|
|
2677
|
+
};
|
|
2678
|
+
/** @description Unknown id or not your batch */
|
|
2679
|
+
404: {
|
|
2680
|
+
headers: {
|
|
2681
|
+
[name: string]: unknown;
|
|
2682
|
+
};
|
|
2683
|
+
content?: never;
|
|
2684
|
+
};
|
|
2685
|
+
};
|
|
2686
|
+
};
|
|
2687
|
+
crawlerFlow: {
|
|
2688
|
+
parameters: {
|
|
2689
|
+
query: {
|
|
2690
|
+
domain: string;
|
|
2691
|
+
agent?: string;
|
|
2692
|
+
fresh?: "1";
|
|
2693
|
+
};
|
|
2694
|
+
header?: never;
|
|
2695
|
+
path?: never;
|
|
2696
|
+
cookie?: never;
|
|
2697
|
+
};
|
|
2698
|
+
requestBody?: never;
|
|
2699
|
+
responses: {
|
|
2700
|
+
/** @description flowmap 1.0: nodes, edges, agents, breaks, summary; evidence (records from 2026-09-20): what each identity received (status, bytes, SHA-256, compared with a browser), what was kept, the manifest and the seal state; with agent=, one identity's path and a one-line answer */
|
|
2701
|
+
200: {
|
|
2702
|
+
headers: {
|
|
2703
|
+
[name: string]: unknown;
|
|
2704
|
+
};
|
|
2705
|
+
content: {
|
|
2706
|
+
"application/json": Record<string, never>;
|
|
2707
|
+
};
|
|
2708
|
+
};
|
|
2709
|
+
/** @description No such identity in the scan */
|
|
2710
|
+
404: {
|
|
2711
|
+
headers: {
|
|
2712
|
+
[name: string]: unknown;
|
|
2713
|
+
};
|
|
2714
|
+
content?: never;
|
|
2715
|
+
};
|
|
2716
|
+
};
|
|
2717
|
+
};
|
|
2718
|
+
flowGate: {
|
|
2719
|
+
parameters: {
|
|
2720
|
+
query: {
|
|
2721
|
+
domain: string;
|
|
2722
|
+
fresh?: "1";
|
|
2723
|
+
since?: string;
|
|
2724
|
+
};
|
|
2725
|
+
header: {
|
|
2726
|
+
"x-crawlcheck-key": string;
|
|
2727
|
+
};
|
|
2728
|
+
path?: never;
|
|
2729
|
+
cookie?: never;
|
|
2730
|
+
};
|
|
2731
|
+
requestBody?: never;
|
|
2732
|
+
responses: {
|
|
2733
|
+
/** @description pass (or no baseline yet, stated in summary) */
|
|
2734
|
+
200: {
|
|
2735
|
+
headers: {
|
|
2736
|
+
[name: string]: unknown;
|
|
2737
|
+
};
|
|
2738
|
+
content: {
|
|
2739
|
+
"application/json": unknown;
|
|
2740
|
+
};
|
|
2741
|
+
};
|
|
2742
|
+
/** @description No licence covering the domain */
|
|
2743
|
+
404: {
|
|
2744
|
+
headers: {
|
|
2745
|
+
[name: string]: unknown;
|
|
2746
|
+
};
|
|
2747
|
+
content?: never;
|
|
2748
|
+
};
|
|
2749
|
+
/** @description No scan on record */
|
|
2750
|
+
409: {
|
|
2751
|
+
headers: {
|
|
2752
|
+
[name: string]: unknown;
|
|
2753
|
+
};
|
|
2754
|
+
content?: never;
|
|
2755
|
+
};
|
|
2756
|
+
/** @description fail: broke[] and declared_violations[] */
|
|
2757
|
+
412: {
|
|
2758
|
+
headers: {
|
|
2759
|
+
[name: string]: unknown;
|
|
2760
|
+
};
|
|
2761
|
+
content?: never;
|
|
2762
|
+
};
|
|
2763
|
+
};
|
|
2764
|
+
};
|
|
2765
|
+
flowDeclaredGet: {
|
|
2766
|
+
parameters: {
|
|
2767
|
+
query: {
|
|
2768
|
+
domain: string;
|
|
2769
|
+
};
|
|
2770
|
+
header: {
|
|
2771
|
+
"x-crawlcheck-key": string;
|
|
2772
|
+
};
|
|
2773
|
+
path?: never;
|
|
2774
|
+
cookie?: never;
|
|
2775
|
+
};
|
|
2776
|
+
requestBody?: never;
|
|
2777
|
+
responses: {
|
|
2778
|
+
/** @description declared, parity[], in_parity */
|
|
2779
|
+
200: {
|
|
2780
|
+
headers: {
|
|
2781
|
+
[name: string]: unknown;
|
|
2782
|
+
};
|
|
2783
|
+
content: {
|
|
2784
|
+
"application/json": unknown;
|
|
2785
|
+
};
|
|
2786
|
+
};
|
|
2787
|
+
/** @description No licence covering the domain, or no declaration */
|
|
2788
|
+
404: {
|
|
2789
|
+
headers: {
|
|
2790
|
+
[name: string]: unknown;
|
|
2791
|
+
};
|
|
2792
|
+
content?: never;
|
|
2793
|
+
};
|
|
2794
|
+
};
|
|
2795
|
+
};
|
|
2796
|
+
flowDeclaredPut: {
|
|
2797
|
+
parameters: {
|
|
2798
|
+
query: {
|
|
2799
|
+
domain: string;
|
|
2800
|
+
};
|
|
2801
|
+
header: {
|
|
2802
|
+
"x-crawlcheck-key": string;
|
|
2803
|
+
};
|
|
2804
|
+
path?: never;
|
|
2805
|
+
cookie?: never;
|
|
2806
|
+
};
|
|
2807
|
+
requestBody: {
|
|
2808
|
+
content: {
|
|
2809
|
+
"application/json": Record<string, never>;
|
|
2810
|
+
};
|
|
2811
|
+
};
|
|
2812
|
+
responses: {
|
|
2813
|
+
/** @description declared, parity[] */
|
|
2814
|
+
200: {
|
|
2815
|
+
headers: {
|
|
2816
|
+
[name: string]: unknown;
|
|
2817
|
+
};
|
|
2818
|
+
content: {
|
|
2819
|
+
"application/json": unknown;
|
|
2820
|
+
};
|
|
2821
|
+
};
|
|
2822
|
+
/** @description Invalid entries */
|
|
2823
|
+
400: {
|
|
2824
|
+
headers: {
|
|
2825
|
+
[name: string]: unknown;
|
|
2826
|
+
};
|
|
2827
|
+
content?: never;
|
|
2828
|
+
};
|
|
2829
|
+
/** @description No licence covering the domain */
|
|
2830
|
+
404: {
|
|
2831
|
+
headers: {
|
|
2832
|
+
[name: string]: unknown;
|
|
2833
|
+
};
|
|
2834
|
+
content?: never;
|
|
2835
|
+
};
|
|
2836
|
+
/** @description No scan to seed from */
|
|
2837
|
+
409: {
|
|
2838
|
+
headers: {
|
|
2839
|
+
[name: string]: unknown;
|
|
2840
|
+
};
|
|
2841
|
+
content?: never;
|
|
2842
|
+
};
|
|
2843
|
+
};
|
|
2844
|
+
};
|
|
2845
|
+
flowDeclaredDelete: {
|
|
2846
|
+
parameters: {
|
|
2847
|
+
query: {
|
|
2848
|
+
domain: string;
|
|
2849
|
+
};
|
|
2850
|
+
header: {
|
|
2851
|
+
"x-crawlcheck-key": string;
|
|
2852
|
+
};
|
|
2853
|
+
path?: never;
|
|
2854
|
+
cookie?: never;
|
|
2855
|
+
};
|
|
2856
|
+
requestBody?: never;
|
|
2857
|
+
responses: {
|
|
2858
|
+
/** @description Deleted */
|
|
2859
|
+
200: {
|
|
2860
|
+
headers: {
|
|
2861
|
+
[name: string]: unknown;
|
|
2862
|
+
};
|
|
2863
|
+
content: {
|
|
2864
|
+
"application/json": unknown;
|
|
2865
|
+
};
|
|
2866
|
+
};
|
|
2867
|
+
};
|
|
2868
|
+
};
|
|
2869
|
+
robotsResolve: {
|
|
2870
|
+
parameters: {
|
|
2871
|
+
query: {
|
|
2872
|
+
domain: string;
|
|
2873
|
+
path?: string;
|
|
2874
|
+
};
|
|
2875
|
+
header?: never;
|
|
2876
|
+
path?: never;
|
|
2877
|
+
cookie?: never;
|
|
2878
|
+
};
|
|
2879
|
+
requestBody?: never;
|
|
2880
|
+
responses: {
|
|
2881
|
+
/** @description Per agent: allowed at the path, allowed_root, named, shadowed */
|
|
2882
|
+
200: {
|
|
2883
|
+
headers: {
|
|
2884
|
+
[name: string]: unknown;
|
|
2885
|
+
};
|
|
2886
|
+
content: {
|
|
2887
|
+
"application/json": Record<string, never>;
|
|
2888
|
+
};
|
|
2889
|
+
};
|
|
2890
|
+
/** @description No domain */
|
|
2891
|
+
400: {
|
|
2892
|
+
headers: {
|
|
2893
|
+
[name: string]: unknown;
|
|
2894
|
+
};
|
|
2895
|
+
content?: never;
|
|
2896
|
+
};
|
|
2897
|
+
};
|
|
2898
|
+
};
|
|
2899
|
+
llmsDraft: {
|
|
2900
|
+
parameters: {
|
|
2901
|
+
query: {
|
|
2902
|
+
domain: string;
|
|
2903
|
+
/** @description txt returns the file itself */
|
|
2904
|
+
format?: "json" | "txt";
|
|
2905
|
+
};
|
|
2906
|
+
header?: never;
|
|
2907
|
+
path?: never;
|
|
2908
|
+
cookie?: never;
|
|
2909
|
+
};
|
|
2910
|
+
requestBody?: never;
|
|
2911
|
+
responses: {
|
|
2912
|
+
/** @description text plus how many pages were declared, read and carried their own description; text/plain when format=txt */
|
|
2913
|
+
200: {
|
|
2914
|
+
headers: {
|
|
2915
|
+
[name: string]: unknown;
|
|
2916
|
+
};
|
|
2917
|
+
content: {
|
|
2918
|
+
"application/json": unknown;
|
|
2919
|
+
};
|
|
2920
|
+
};
|
|
2921
|
+
/** @description No domain */
|
|
2922
|
+
400: {
|
|
2923
|
+
headers: {
|
|
2924
|
+
[name: string]: unknown;
|
|
2925
|
+
};
|
|
2926
|
+
content?: never;
|
|
2927
|
+
};
|
|
2928
|
+
};
|
|
2929
|
+
};
|
|
2930
|
+
videoCheck: {
|
|
2931
|
+
parameters: {
|
|
2932
|
+
query: {
|
|
2933
|
+
/** @description A video id or URL */
|
|
2934
|
+
v: string;
|
|
2935
|
+
/** @description Bypass the cache */
|
|
2936
|
+
fresh?: "1";
|
|
2937
|
+
};
|
|
2938
|
+
header?: never;
|
|
2939
|
+
path?: never;
|
|
2940
|
+
cookie?: never;
|
|
2941
|
+
};
|
|
2942
|
+
requestBody?: never;
|
|
2943
|
+
responses: {
|
|
2944
|
+
/** @description video, chapters, captions, storyboard, thumbnail, checks{rows, passed, scored}, not_measurable */
|
|
2945
|
+
200: {
|
|
2946
|
+
headers: {
|
|
2947
|
+
[name: string]: unknown;
|
|
2948
|
+
};
|
|
2949
|
+
content: {
|
|
2950
|
+
"application/json": Record<string, never>;
|
|
2951
|
+
};
|
|
2952
|
+
};
|
|
2953
|
+
/** @description No such video */
|
|
2954
|
+
404: {
|
|
2955
|
+
headers: {
|
|
2956
|
+
[name: string]: unknown;
|
|
2957
|
+
};
|
|
2958
|
+
content?: never;
|
|
2959
|
+
};
|
|
2960
|
+
};
|
|
2961
|
+
};
|
|
2962
|
+
videoChannel: {
|
|
2963
|
+
parameters: {
|
|
2964
|
+
query?: {
|
|
2965
|
+
/** @description @channel; give this or id */
|
|
2966
|
+
handle?: string;
|
|
2967
|
+
/** @description Channel id */
|
|
2968
|
+
id?: string;
|
|
2969
|
+
/** @description Check every upload and tally per check */
|
|
2970
|
+
checks?: "1";
|
|
2971
|
+
};
|
|
2972
|
+
header?: never;
|
|
2973
|
+
path?: never;
|
|
2974
|
+
cookie?: never;
|
|
2975
|
+
};
|
|
2976
|
+
requestBody?: never;
|
|
2977
|
+
responses: {
|
|
2978
|
+
/** @description rollup{check: {pass, judged, na}} and videos[] sorted by views */
|
|
2979
|
+
200: {
|
|
2980
|
+
headers: {
|
|
2981
|
+
[name: string]: unknown;
|
|
2982
|
+
};
|
|
2983
|
+
content: {
|
|
2984
|
+
"application/json": Record<string, never>;
|
|
2985
|
+
};
|
|
2986
|
+
};
|
|
2987
|
+
/** @description No such channel */
|
|
2988
|
+
404: {
|
|
2989
|
+
headers: {
|
|
2990
|
+
[name: string]: unknown;
|
|
2991
|
+
};
|
|
2992
|
+
content?: never;
|
|
2993
|
+
};
|
|
2994
|
+
};
|
|
2995
|
+
};
|
|
2996
|
+
videoSite: {
|
|
2997
|
+
parameters: {
|
|
2998
|
+
query: {
|
|
2999
|
+
domain: string;
|
|
3000
|
+
handle?: string;
|
|
3001
|
+
};
|
|
3002
|
+
header?: never;
|
|
3003
|
+
path?: never;
|
|
3004
|
+
cookie?: never;
|
|
3005
|
+
};
|
|
3006
|
+
requestBody?: never;
|
|
3007
|
+
responses: {
|
|
3008
|
+
/** @description pages[] with embeds and VideoObject counts, videos{} keyed by id, rows[] with passed/scored */
|
|
3009
|
+
200: {
|
|
3010
|
+
headers: {
|
|
3011
|
+
[name: string]: unknown;
|
|
3012
|
+
};
|
|
3013
|
+
content: {
|
|
3014
|
+
"application/json": Record<string, never>;
|
|
3015
|
+
};
|
|
3016
|
+
};
|
|
3017
|
+
/** @description No domain */
|
|
3018
|
+
400: {
|
|
3019
|
+
headers: {
|
|
3020
|
+
[name: string]: unknown;
|
|
3021
|
+
};
|
|
3022
|
+
content?: never;
|
|
3023
|
+
};
|
|
3024
|
+
};
|
|
3025
|
+
};
|
|
3026
|
+
fixRobots: {
|
|
3027
|
+
parameters: {
|
|
3028
|
+
query: {
|
|
3029
|
+
domain: string;
|
|
3030
|
+
/** @description The notes as data instead of the file */
|
|
3031
|
+
format?: "json";
|
|
3032
|
+
};
|
|
3033
|
+
header?: never;
|
|
3034
|
+
path?: never;
|
|
3035
|
+
cookie?: never;
|
|
3036
|
+
};
|
|
3037
|
+
requestBody?: never;
|
|
3038
|
+
responses: {
|
|
3039
|
+
/** @description text/plain robots.txt, or JSON when format=json */
|
|
3040
|
+
200: {
|
|
3041
|
+
headers: {
|
|
3042
|
+
[name: string]: unknown;
|
|
3043
|
+
};
|
|
3044
|
+
content: {
|
|
3045
|
+
"text/plain": unknown;
|
|
3046
|
+
};
|
|
3047
|
+
};
|
|
3048
|
+
/** @description No domain */
|
|
3049
|
+
400: {
|
|
3050
|
+
headers: {
|
|
3051
|
+
[name: string]: unknown;
|
|
3052
|
+
};
|
|
3053
|
+
content?: never;
|
|
3054
|
+
};
|
|
3055
|
+
};
|
|
3056
|
+
};
|
|
3057
|
+
fixEntitymap: {
|
|
3058
|
+
parameters: {
|
|
3059
|
+
query: {
|
|
3060
|
+
domain: string;
|
|
3061
|
+
};
|
|
3062
|
+
header?: never;
|
|
3063
|
+
path?: never;
|
|
3064
|
+
cookie?: never;
|
|
3065
|
+
};
|
|
3066
|
+
requestBody?: never;
|
|
3067
|
+
responses: {
|
|
3068
|
+
/** @description application/json, downloadable as entitymap.json */
|
|
3069
|
+
200: {
|
|
3070
|
+
headers: {
|
|
3071
|
+
[name: string]: unknown;
|
|
3072
|
+
};
|
|
3073
|
+
content: {
|
|
3074
|
+
"application/json": unknown;
|
|
3075
|
+
};
|
|
3076
|
+
};
|
|
3077
|
+
/** @description No prior scan for this domain */
|
|
3078
|
+
404: {
|
|
3079
|
+
headers: {
|
|
3080
|
+
[name: string]: unknown;
|
|
3081
|
+
};
|
|
3082
|
+
content?: never;
|
|
3083
|
+
};
|
|
3084
|
+
};
|
|
3085
|
+
};
|
|
3086
|
+
entityObserve: {
|
|
3087
|
+
parameters: {
|
|
3088
|
+
query?: never;
|
|
3089
|
+
header: {
|
|
3090
|
+
"x-crawlcheck-key": string;
|
|
3091
|
+
};
|
|
3092
|
+
path?: never;
|
|
3093
|
+
cookie?: never;
|
|
3094
|
+
};
|
|
3095
|
+
requestBody: {
|
|
3096
|
+
content: {
|
|
3097
|
+
"application/json": {
|
|
3098
|
+
/** @description The profile URL as declared in sameAs */
|
|
3099
|
+
url: string;
|
|
3100
|
+
/** @description The whole page as the browser saw it; at least 512 bytes, the first 200 KB are kept */
|
|
3101
|
+
html: string;
|
|
3102
|
+
/** @description Defaults to owner-browser */
|
|
3103
|
+
vantage?: string;
|
|
3104
|
+
};
|
|
3105
|
+
"application/x-www-form-urlencoded": {
|
|
3106
|
+
/** @description The same JSON object as a form field */
|
|
3107
|
+
payload: string;
|
|
3108
|
+
};
|
|
3109
|
+
};
|
|
3110
|
+
};
|
|
3111
|
+
responses: {
|
|
3112
|
+
/** @description key, sha, bytes, at, expires_days, bound_to (the licence's domains) */
|
|
3113
|
+
200: {
|
|
3114
|
+
headers: {
|
|
3115
|
+
[name: string]: unknown;
|
|
3116
|
+
};
|
|
3117
|
+
content: {
|
|
3118
|
+
"application/json": unknown;
|
|
3119
|
+
};
|
|
3120
|
+
};
|
|
3121
|
+
/** @description No url or html, page under 512 bytes, or the page's canonical names another host */
|
|
3122
|
+
400: {
|
|
3123
|
+
headers: {
|
|
3124
|
+
[name: string]: unknown;
|
|
3125
|
+
};
|
|
3126
|
+
content?: never;
|
|
3127
|
+
};
|
|
3128
|
+
/** @description No valid licence key */
|
|
3129
|
+
404: {
|
|
3130
|
+
headers: {
|
|
3131
|
+
[name: string]: unknown;
|
|
3132
|
+
};
|
|
3133
|
+
content?: never;
|
|
3134
|
+
};
|
|
3135
|
+
};
|
|
3136
|
+
};
|
|
3137
|
+
publicCounts: {
|
|
3138
|
+
parameters: {
|
|
3139
|
+
query?: never;
|
|
3140
|
+
header?: never;
|
|
3141
|
+
path?: never;
|
|
3142
|
+
cookie?: never;
|
|
3143
|
+
};
|
|
3144
|
+
requestBody?: never;
|
|
3145
|
+
responses: {
|
|
3146
|
+
/** @description JSON */
|
|
3147
|
+
200: {
|
|
3148
|
+
headers: {
|
|
3149
|
+
[name: string]: unknown;
|
|
3150
|
+
};
|
|
3151
|
+
content: {
|
|
3152
|
+
"application/json": Record<string, never>;
|
|
3153
|
+
};
|
|
3154
|
+
};
|
|
3155
|
+
};
|
|
3156
|
+
};
|
|
3157
|
+
registry: {
|
|
3158
|
+
parameters: {
|
|
3159
|
+
query?: {
|
|
3160
|
+
/** @description One domain. Returns that row, or 404 when the domain is not listed. */
|
|
3161
|
+
host?: string;
|
|
3162
|
+
shelf?: "llms" | "agents" | "mediakit" | "entity" | "aipolicy" | "agentapi";
|
|
3163
|
+
limit?: number;
|
|
3164
|
+
/** @description Rows to skip. The response carries next, the URL of the following page, and complete: true on the last one */
|
|
3165
|
+
offset?: number;
|
|
3166
|
+
/** @description Opaque cursor from a previous response */
|
|
3167
|
+
cursor?: string;
|
|
3168
|
+
};
|
|
3169
|
+
header?: never;
|
|
3170
|
+
path?: never;
|
|
3171
|
+
cookie?: never;
|
|
3172
|
+
};
|
|
3173
|
+
requestBody?: never;
|
|
3174
|
+
responses: {
|
|
3175
|
+
/** @description Shelf counts and rows */
|
|
3176
|
+
200: {
|
|
3177
|
+
headers: {
|
|
3178
|
+
[name: string]: unknown;
|
|
3179
|
+
};
|
|
3180
|
+
content: {
|
|
3181
|
+
"application/json": Record<string, never>;
|
|
3182
|
+
};
|
|
3183
|
+
};
|
|
3184
|
+
/** @description That domain is not listed */
|
|
3185
|
+
404: {
|
|
3186
|
+
headers: {
|
|
3187
|
+
[name: string]: unknown;
|
|
3188
|
+
};
|
|
3189
|
+
content?: never;
|
|
3190
|
+
};
|
|
3191
|
+
};
|
|
3192
|
+
};
|
|
3193
|
+
telemetry: {
|
|
3194
|
+
parameters: {
|
|
3195
|
+
query?: never;
|
|
3196
|
+
header?: never;
|
|
3197
|
+
path?: never;
|
|
3198
|
+
cookie?: never;
|
|
3199
|
+
};
|
|
3200
|
+
requestBody?: never;
|
|
3201
|
+
responses: {
|
|
3202
|
+
/** @description JSON */
|
|
3203
|
+
200: {
|
|
3204
|
+
headers: {
|
|
3205
|
+
[name: string]: unknown;
|
|
3206
|
+
};
|
|
3207
|
+
content: {
|
|
3208
|
+
"application/json": Record<string, never>;
|
|
3209
|
+
};
|
|
3210
|
+
};
|
|
3211
|
+
};
|
|
3212
|
+
};
|
|
3213
|
+
corpusState: {
|
|
3214
|
+
parameters: {
|
|
3215
|
+
query?: never;
|
|
3216
|
+
header?: never;
|
|
3217
|
+
path?: never;
|
|
3218
|
+
cookie?: never;
|
|
3219
|
+
};
|
|
3220
|
+
requestBody?: never;
|
|
3221
|
+
responses: {
|
|
3222
|
+
/** @description JSON */
|
|
3223
|
+
200: {
|
|
3224
|
+
headers: {
|
|
3225
|
+
[name: string]: unknown;
|
|
3226
|
+
};
|
|
3227
|
+
content: {
|
|
3228
|
+
"application/json": Record<string, never>;
|
|
3229
|
+
};
|
|
3230
|
+
};
|
|
3231
|
+
};
|
|
3232
|
+
};
|
|
3233
|
+
}
|