@maycombhq/sdk 2.0.0-beta.23 → 2.0.0-beta.25
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/npm/core/api.d.ts +530 -30
- package/npm/core/cite.d.ts +13 -2
- package/npm/core/facts-deps.d.ts +85 -0
- package/npm/core/facts-join.d.ts +33 -7
- package/npm/core/facts.d.ts +59 -0
- package/npm/core/host-questions.d.ts +180 -0
- package/npm/core/identity.d.ts +1 -17
- package/npm/core/index.d.ts +1 -0
- package/npm/core/paths.d.ts +23 -0
- package/npm/core/questions.d.ts +14 -0
- package/npm/core/schema/ai.d.ts +2 -2
- package/npm/core/schema/dialect.d.ts +12 -12
- package/npm/core/schema/fact-corrections.d.ts +2 -0
- package/npm/core/schema/facts.d.ts +315 -4
- package/npm/core/schema/frameworks.d.ts +10 -10
- package/npm/core/schema/review.d.ts +2 -2
- package/npm/core/schema/scan-verify.d.ts +45 -45
- package/npm/index.js +5530 -4902
- package/package.json +1 -1
|
@@ -8,14 +8,14 @@ import { z } from "zod";
|
|
|
8
8
|
export declare const DIALECT_SCHEMA_VERSION: 1;
|
|
9
9
|
/** Grammars shipped with Atticus for syntax matches (ADR 0060). */
|
|
10
10
|
export declare const SyntaxLanguage: z.ZodEnum<{
|
|
11
|
+
python: "python";
|
|
12
|
+
go: "go";
|
|
11
13
|
java: "java";
|
|
12
14
|
kotlin: "kotlin";
|
|
13
15
|
typescript: "typescript";
|
|
14
16
|
tsx: "tsx";
|
|
15
17
|
javascript: "javascript";
|
|
16
18
|
c_sharp: "c_sharp";
|
|
17
|
-
python: "python";
|
|
18
|
-
go: "go";
|
|
19
19
|
scala: "scala";
|
|
20
20
|
ruby: "ruby";
|
|
21
21
|
php: "php";
|
|
@@ -59,14 +59,14 @@ export declare const DialectMatch: z.ZodUnion<readonly [z.ZodObject<{
|
|
|
59
59
|
contains: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
|
|
60
60
|
syntax: z.ZodString;
|
|
61
61
|
language: z.ZodOptional<z.ZodEnum<{
|
|
62
|
+
python: "python";
|
|
63
|
+
go: "go";
|
|
62
64
|
java: "java";
|
|
63
65
|
kotlin: "kotlin";
|
|
64
66
|
typescript: "typescript";
|
|
65
67
|
tsx: "tsx";
|
|
66
68
|
javascript: "javascript";
|
|
67
69
|
c_sharp: "c_sharp";
|
|
68
|
-
python: "python";
|
|
69
|
-
go: "go";
|
|
70
70
|
scala: "scala";
|
|
71
71
|
ruby: "ruby";
|
|
72
72
|
php: "php";
|
|
@@ -208,14 +208,14 @@ export declare const DialectRule: z.ZodObject<{
|
|
|
208
208
|
contains: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
|
|
209
209
|
syntax: z.ZodString;
|
|
210
210
|
language: z.ZodOptional<z.ZodEnum<{
|
|
211
|
+
python: "python";
|
|
212
|
+
go: "go";
|
|
211
213
|
java: "java";
|
|
212
214
|
kotlin: "kotlin";
|
|
213
215
|
typescript: "typescript";
|
|
214
216
|
tsx: "tsx";
|
|
215
217
|
javascript: "javascript";
|
|
216
218
|
c_sharp: "c_sharp";
|
|
217
|
-
python: "python";
|
|
218
|
-
go: "go";
|
|
219
219
|
scala: "scala";
|
|
220
220
|
ruby: "ruby";
|
|
221
221
|
php: "php";
|
|
@@ -405,14 +405,14 @@ export declare const DialectLookup: z.ZodObject<{
|
|
|
405
405
|
contains: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
|
|
406
406
|
syntax: z.ZodString;
|
|
407
407
|
language: z.ZodOptional<z.ZodEnum<{
|
|
408
|
+
python: "python";
|
|
409
|
+
go: "go";
|
|
408
410
|
java: "java";
|
|
409
411
|
kotlin: "kotlin";
|
|
410
412
|
typescript: "typescript";
|
|
411
413
|
tsx: "tsx";
|
|
412
414
|
javascript: "javascript";
|
|
413
415
|
c_sharp: "c_sharp";
|
|
414
|
-
python: "python";
|
|
415
|
-
go: "go";
|
|
416
416
|
scala: "scala";
|
|
417
417
|
ruby: "ruby";
|
|
418
418
|
php: "php";
|
|
@@ -534,14 +534,14 @@ export declare const Dialect: z.ZodObject<{
|
|
|
534
534
|
contains: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
|
|
535
535
|
syntax: z.ZodString;
|
|
536
536
|
language: z.ZodOptional<z.ZodEnum<{
|
|
537
|
+
python: "python";
|
|
538
|
+
go: "go";
|
|
537
539
|
java: "java";
|
|
538
540
|
kotlin: "kotlin";
|
|
539
541
|
typescript: "typescript";
|
|
540
542
|
tsx: "tsx";
|
|
541
543
|
javascript: "javascript";
|
|
542
544
|
c_sharp: "c_sharp";
|
|
543
|
-
python: "python";
|
|
544
|
-
go: "go";
|
|
545
545
|
scala: "scala";
|
|
546
546
|
ruby: "ruby";
|
|
547
547
|
php: "php";
|
|
@@ -600,14 +600,14 @@ export declare const Dialect: z.ZodObject<{
|
|
|
600
600
|
contains: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
|
|
601
601
|
syntax: z.ZodString;
|
|
602
602
|
language: z.ZodOptional<z.ZodEnum<{
|
|
603
|
+
python: "python";
|
|
604
|
+
go: "go";
|
|
603
605
|
java: "java";
|
|
604
606
|
kotlin: "kotlin";
|
|
605
607
|
typescript: "typescript";
|
|
606
608
|
tsx: "tsx";
|
|
607
609
|
javascript: "javascript";
|
|
608
610
|
c_sharp: "c_sharp";
|
|
609
|
-
python: "python";
|
|
610
|
-
go: "go";
|
|
611
611
|
scala: "scala";
|
|
612
612
|
ruby: "ruby";
|
|
613
613
|
php: "php";
|
|
@@ -59,6 +59,7 @@ export declare const FactCorrection: z.ZodObject<{
|
|
|
59
59
|
config: "config";
|
|
60
60
|
component: "component";
|
|
61
61
|
field: "field";
|
|
62
|
+
dependency: "dependency";
|
|
62
63
|
term: "term";
|
|
63
64
|
framework: "framework";
|
|
64
65
|
entry: "entry";
|
|
@@ -66,6 +67,7 @@ export declare const FactCorrection: z.ZodObject<{
|
|
|
66
67
|
call: "call";
|
|
67
68
|
deploy: "deploy";
|
|
68
69
|
flow: "flow";
|
|
70
|
+
artifact: "artifact";
|
|
69
71
|
}>;
|
|
70
72
|
file: z.ZodString;
|
|
71
73
|
line: z.ZodNumber;
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { z } from "zod";
|
|
2
|
-
export declare const FACT_KINDS: readonly ["entry", "call", "store", "field", "deploy", "config", "framework", "flow", "term", "component"];
|
|
2
|
+
export declare const FACT_KINDS: readonly ["entry", "call", "store", "field", "deploy", "config", "framework", "flow", "term", "component", "artifact", "dependency"];
|
|
3
3
|
export type FactKind = (typeof FACT_KINDS)[number];
|
|
4
4
|
/** A fact's id: any slug the assistant chooses; the projection makes catalog ids from the claim. */
|
|
5
5
|
export declare const FactId: z.ZodString;
|
|
@@ -422,14 +422,60 @@ export declare const DeployFact: z.ZodObject<{
|
|
|
422
422
|
* 1: the shapes of ADR 0124 and its addenda. 2: a deploy fact's `host`, `basePath` and `exposes`.
|
|
423
423
|
* 3 (ADR 0163): the `term` kind, and a call's `auth`, `authCite`, `tls` and `tlsCite`.
|
|
424
424
|
* 4 (ADR 0180): the `component` kind, what a component is.
|
|
425
|
+
* 5 (ADR 0192): the `artifact` and `dependency` kinds, a component's build coordinates and what
|
|
426
|
+
* it builds on. A version-4 file reads unchanged: both are new kinds, nothing else moved.
|
|
427
|
+
*
|
|
428
|
+
* ADR 0192 addendum (beta.25), no version change: a pom's `<scope>system</scope>` is recorded as
|
|
429
|
+
* `provided` (it is drawn so), so 2.0.0-beta.25 reads every file 2.0.0-beta.25 writes. A reader of
|
|
430
|
+
* beta.25 or later leaves out, one fact at a time, a fact a newer Atticus wrote (a kind it doesn't
|
|
431
|
+
* know, or a known kind with a value or a field it doesn't), said as such (`parseFacts`' `newer`),
|
|
432
|
+
* rather than refusing the whole file, and `atticus verify --write` keeps that line as written.
|
|
425
433
|
*/
|
|
426
|
-
export declare const FACTS_SCHEMA_VERSION:
|
|
434
|
+
export declare const FACTS_SCHEMA_VERSION: 5;
|
|
427
435
|
export declare const SETTING_KINDS: readonly ["timeout", "retry", "circuit-breaker", "rate-limit", "pool", "cache-ttl", "feature-flag", "config", "schedule"];
|
|
428
436
|
/**
|
|
429
|
-
* Whether a key and its value look like a secret: the key
|
|
430
|
-
* and the value is neither a reference to where the
|
|
437
|
+
* Whether a key and its value look like a secret: a name the key gives (its last part, a
|
|
438
|
+
* bracketed name) ends in a secret word, and the value is neither a reference to where the
|
|
439
|
+
* secret lives nor a flag or a mode.
|
|
431
440
|
*/
|
|
432
441
|
export declare function looksLikeSecret(key: string, value: string | undefined): boolean;
|
|
442
|
+
/**
|
|
443
|
+
* Whether a literal under a secret's key reads as a credential (`configSecretField`): token-like,
|
|
444
|
+
* no name as people write them (`NAME_LIKE`), and strong enough (`credentialStrength`).
|
|
445
|
+
*/
|
|
446
|
+
export declare function credentialLike(t: string): boolean;
|
|
447
|
+
/**
|
|
448
|
+
* Beta.25 review: where a config fact carries its setting's secret, the field that does
|
|
449
|
+
* (`value`, `source` or `cite.with`), or undefined. The verifier refuses such a fact
|
|
450
|
+
* (`secret-value`); the schema keeps only beta.24's value check, as released, so a facts file
|
|
451
|
+
* read before is read the same (ADR 0124 addendum A-gateway-outside-2).
|
|
452
|
+
*
|
|
453
|
+
* A value is one when its key names a secret (`looksLikeSecret`) or it is shaped like one
|
|
454
|
+
* (`hasSecretShape`, a Basic token too). A source or a part is one when it is shaped like a
|
|
455
|
+
* secret whatever the key. Under a key that names a secret, a value, a source or a part with a
|
|
456
|
+
* placeholder whose default is a literal (`${DB_PASSWORD:hunter22}`) is one; a source is one
|
|
457
|
+
* when it is no reference (`isReference`), no name as code writes one (`identifierName`) and no
|
|
458
|
+
* name of the fact's own, however weak (`hunter22`, `Summer2024!`); and a part is one when it
|
|
459
|
+
* is a literal that reads as a credential (`credentialLike`) or a password by its marks
|
|
460
|
+
* (`Summer2024!`; a weak word with digits, `hunter22`, is shaped as a hash or a version is, so
|
|
461
|
+
* a part like it is not refused here, and the verifier's messages never quote it) and is no
|
|
462
|
+
* name of the fact's own:
|
|
463
|
+
* its key or a name in it, its target with or without its extension, its env, or a name its
|
|
464
|
+
* source gives (the part `northwind-oauth2` of `secretKeyRef:northwind-oauth2/client-secret`).
|
|
465
|
+
* A quote is the verifier's to redact, as it always was. The answer never repeats the value.
|
|
466
|
+
*/
|
|
467
|
+
export declare function configSecretField(c: {
|
|
468
|
+
key: string;
|
|
469
|
+
value?: string | undefined;
|
|
470
|
+
source?: string | undefined;
|
|
471
|
+
target?: string | undefined;
|
|
472
|
+
env?: string | undefined;
|
|
473
|
+
cite: {
|
|
474
|
+
with?: readonly {
|
|
475
|
+
value: string;
|
|
476
|
+
}[] | undefined;
|
|
477
|
+
};
|
|
478
|
+
}): "value" | "source" | "cite.with" | undefined;
|
|
433
479
|
export declare const ConfigFact: z.ZodObject<{
|
|
434
480
|
settingKind: z.ZodDefault<z.ZodEnum<{
|
|
435
481
|
config: "config";
|
|
@@ -762,6 +808,117 @@ export declare const ComponentFact: z.ZodObject<{
|
|
|
762
808
|
}>>;
|
|
763
809
|
kind: z.ZodLiteral<"component">;
|
|
764
810
|
}, z.core.$strict>;
|
|
811
|
+
/**
|
|
812
|
+
* What a component's build publishes (ADR 0192): its own coordinates, `group` and `name` (a
|
|
813
|
+
* pom's project `<groupId>` and `<artifactId>`, a Gradle project's `group` and name). `cite` is the
|
|
814
|
+
* line that writes the name (the project's own `<artifactId>`, `rootProject.name`); the line that
|
|
815
|
+
* writes the group, when it is another (the project's `<groupId>`, the `<parent>`'s when the
|
|
816
|
+
* project inherits it, `group = '...'` in build.gradle), goes in `cite.with`, as does the
|
|
817
|
+
* version's. The verifier reads the build file to check each is what that line says, and that
|
|
818
|
+
* the name is the project's own, never a dependency's or a parent's.
|
|
819
|
+
*
|
|
820
|
+
* Nothing is projected into catalog C1 from it, as with a framework fact: the views read it, and
|
|
821
|
+
* the estate's dependency join (`joinDependencies`) pairs it with the `dependency` facts that name
|
|
822
|
+
* the same coordinates.
|
|
823
|
+
*/
|
|
824
|
+
export declare const ArtifactFact: z.ZodObject<{
|
|
825
|
+
group: z.ZodString;
|
|
826
|
+
name: z.ZodString;
|
|
827
|
+
version: z.ZodOptional<z.ZodString>;
|
|
828
|
+
id: z.ZodString;
|
|
829
|
+
repo: z.ZodString;
|
|
830
|
+
commit: z.ZodString;
|
|
831
|
+
component: z.ZodOptional<z.ZodString>;
|
|
832
|
+
cite: z.ZodObject<{
|
|
833
|
+
file: z.ZodString;
|
|
834
|
+
line: z.ZodNumber;
|
|
835
|
+
value: z.ZodString;
|
|
836
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
837
|
+
with: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
838
|
+
file: z.ZodString;
|
|
839
|
+
line: z.ZodNumber;
|
|
840
|
+
value: z.ZodString;
|
|
841
|
+
}, z.core.$strict>>>;
|
|
842
|
+
}, z.core.$strict>;
|
|
843
|
+
verified: z.ZodDefault<z.ZodEnum<{
|
|
844
|
+
line: "line";
|
|
845
|
+
none: "none";
|
|
846
|
+
person: "person";
|
|
847
|
+
sample: "sample";
|
|
848
|
+
}>>;
|
|
849
|
+
by: z.ZodDefault<z.ZodEnum<{
|
|
850
|
+
person: "person";
|
|
851
|
+
assistant: "assistant";
|
|
852
|
+
reader: "reader";
|
|
853
|
+
}>>;
|
|
854
|
+
conf: z.ZodDefault<z.ZodEnum<{
|
|
855
|
+
inferred: "inferred";
|
|
856
|
+
declared: "declared";
|
|
857
|
+
}>>;
|
|
858
|
+
kind: z.ZodLiteral<"artifact">;
|
|
859
|
+
}, z.core.$strict>;
|
|
860
|
+
/**
|
|
861
|
+
* A dependency's scope (ADR 0192): Maven's, or what a Gradle configuration means. A pom's
|
|
862
|
+
* `<scope>system</scope>` (a jar from a path on the machine) is recorded as `provided`, which is
|
|
863
|
+
* how it is drawn (ADR 0192 addendum).
|
|
864
|
+
*/
|
|
865
|
+
export declare const DEPENDENCY_SCOPES: readonly ["compile", "runtime", "provided", "test", "import"];
|
|
866
|
+
export type DependencyScope = (typeof DEPENDENCY_SCOPES)[number];
|
|
867
|
+
/**
|
|
868
|
+
* A build dependency a component declares (ADR 0192): the `group` and `name` of what it builds
|
|
869
|
+
* on, as the build file declares it in its dependencies (not a dependency-management block, a
|
|
870
|
+
* plugin or an exclusion). `cite` is the line that writes the name (the dependency's
|
|
871
|
+
* `<artifactId>`, a Gradle `implementation 'g:a:v'` line); the dependency's `<groupId>` line, when
|
|
872
|
+
* it is another, goes in `cite.with`. `scope` is the declared scope, left out for the default
|
|
873
|
+
* (compile). The dependency belongs to the component whose build file cites it: a module's pom
|
|
874
|
+
* is its module's.
|
|
875
|
+
*
|
|
876
|
+
* Every dependency is recorded, the organisation's own or not: which one is the estate's own is
|
|
877
|
+
* the dependency join's to say, from the coordinates the estate's `artifact` facts publish.
|
|
878
|
+
*/
|
|
879
|
+
export declare const DependencyFact: z.ZodObject<{
|
|
880
|
+
group: z.ZodString;
|
|
881
|
+
name: z.ZodString;
|
|
882
|
+
version: z.ZodOptional<z.ZodString>;
|
|
883
|
+
scope: z.ZodOptional<z.ZodEnum<{
|
|
884
|
+
runtime: "runtime";
|
|
885
|
+
compile: "compile";
|
|
886
|
+
provided: "provided";
|
|
887
|
+
test: "test";
|
|
888
|
+
import: "import";
|
|
889
|
+
}>>;
|
|
890
|
+
id: z.ZodString;
|
|
891
|
+
repo: z.ZodString;
|
|
892
|
+
commit: z.ZodString;
|
|
893
|
+
component: z.ZodOptional<z.ZodString>;
|
|
894
|
+
cite: z.ZodObject<{
|
|
895
|
+
file: z.ZodString;
|
|
896
|
+
line: z.ZodNumber;
|
|
897
|
+
value: z.ZodString;
|
|
898
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
899
|
+
with: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
900
|
+
file: z.ZodString;
|
|
901
|
+
line: z.ZodNumber;
|
|
902
|
+
value: z.ZodString;
|
|
903
|
+
}, z.core.$strict>>>;
|
|
904
|
+
}, z.core.$strict>;
|
|
905
|
+
verified: z.ZodDefault<z.ZodEnum<{
|
|
906
|
+
line: "line";
|
|
907
|
+
none: "none";
|
|
908
|
+
person: "person";
|
|
909
|
+
sample: "sample";
|
|
910
|
+
}>>;
|
|
911
|
+
by: z.ZodDefault<z.ZodEnum<{
|
|
912
|
+
person: "person";
|
|
913
|
+
assistant: "assistant";
|
|
914
|
+
reader: "reader";
|
|
915
|
+
}>>;
|
|
916
|
+
conf: z.ZodDefault<z.ZodEnum<{
|
|
917
|
+
inferred: "inferred";
|
|
918
|
+
declared: "declared";
|
|
919
|
+
}>>;
|
|
920
|
+
kind: z.ZodLiteral<"dependency">;
|
|
921
|
+
}, z.core.$strict>;
|
|
765
922
|
export declare const Fact: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
766
923
|
entryType: z.ZodEnum<{
|
|
767
924
|
function: "function";
|
|
@@ -1319,6 +1476,83 @@ export declare const Fact: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
1319
1476
|
declared: "declared";
|
|
1320
1477
|
}>>;
|
|
1321
1478
|
kind: z.ZodLiteral<"component">;
|
|
1479
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1480
|
+
group: z.ZodString;
|
|
1481
|
+
name: z.ZodString;
|
|
1482
|
+
version: z.ZodOptional<z.ZodString>;
|
|
1483
|
+
id: z.ZodString;
|
|
1484
|
+
repo: z.ZodString;
|
|
1485
|
+
commit: z.ZodString;
|
|
1486
|
+
component: z.ZodOptional<z.ZodString>;
|
|
1487
|
+
cite: z.ZodObject<{
|
|
1488
|
+
file: z.ZodString;
|
|
1489
|
+
line: z.ZodNumber;
|
|
1490
|
+
value: z.ZodString;
|
|
1491
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
1492
|
+
with: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1493
|
+
file: z.ZodString;
|
|
1494
|
+
line: z.ZodNumber;
|
|
1495
|
+
value: z.ZodString;
|
|
1496
|
+
}, z.core.$strict>>>;
|
|
1497
|
+
}, z.core.$strict>;
|
|
1498
|
+
verified: z.ZodDefault<z.ZodEnum<{
|
|
1499
|
+
line: "line";
|
|
1500
|
+
none: "none";
|
|
1501
|
+
person: "person";
|
|
1502
|
+
sample: "sample";
|
|
1503
|
+
}>>;
|
|
1504
|
+
by: z.ZodDefault<z.ZodEnum<{
|
|
1505
|
+
person: "person";
|
|
1506
|
+
assistant: "assistant";
|
|
1507
|
+
reader: "reader";
|
|
1508
|
+
}>>;
|
|
1509
|
+
conf: z.ZodDefault<z.ZodEnum<{
|
|
1510
|
+
inferred: "inferred";
|
|
1511
|
+
declared: "declared";
|
|
1512
|
+
}>>;
|
|
1513
|
+
kind: z.ZodLiteral<"artifact">;
|
|
1514
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1515
|
+
group: z.ZodString;
|
|
1516
|
+
name: z.ZodString;
|
|
1517
|
+
version: z.ZodOptional<z.ZodString>;
|
|
1518
|
+
scope: z.ZodOptional<z.ZodEnum<{
|
|
1519
|
+
runtime: "runtime";
|
|
1520
|
+
compile: "compile";
|
|
1521
|
+
provided: "provided";
|
|
1522
|
+
test: "test";
|
|
1523
|
+
import: "import";
|
|
1524
|
+
}>>;
|
|
1525
|
+
id: z.ZodString;
|
|
1526
|
+
repo: z.ZodString;
|
|
1527
|
+
commit: z.ZodString;
|
|
1528
|
+
component: z.ZodOptional<z.ZodString>;
|
|
1529
|
+
cite: z.ZodObject<{
|
|
1530
|
+
file: z.ZodString;
|
|
1531
|
+
line: z.ZodNumber;
|
|
1532
|
+
value: z.ZodString;
|
|
1533
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
1534
|
+
with: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1535
|
+
file: z.ZodString;
|
|
1536
|
+
line: z.ZodNumber;
|
|
1537
|
+
value: z.ZodString;
|
|
1538
|
+
}, z.core.$strict>>>;
|
|
1539
|
+
}, z.core.$strict>;
|
|
1540
|
+
verified: z.ZodDefault<z.ZodEnum<{
|
|
1541
|
+
line: "line";
|
|
1542
|
+
none: "none";
|
|
1543
|
+
person: "person";
|
|
1544
|
+
sample: "sample";
|
|
1545
|
+
}>>;
|
|
1546
|
+
by: z.ZodDefault<z.ZodEnum<{
|
|
1547
|
+
person: "person";
|
|
1548
|
+
assistant: "assistant";
|
|
1549
|
+
reader: "reader";
|
|
1550
|
+
}>>;
|
|
1551
|
+
conf: z.ZodDefault<z.ZodEnum<{
|
|
1552
|
+
inferred: "inferred";
|
|
1553
|
+
declared: "declared";
|
|
1554
|
+
}>>;
|
|
1555
|
+
kind: z.ZodLiteral<"dependency">;
|
|
1322
1556
|
}, z.core.$strict>], "kind">;
|
|
1323
1557
|
export type Fact = z.infer<typeof Fact>;
|
|
1324
1558
|
export type FactOf<K extends FactKind> = Extract<Fact, {
|
|
@@ -1882,4 +2116,81 @@ export declare const FactsFile: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<
|
|
|
1882
2116
|
declared: "declared";
|
|
1883
2117
|
}>>;
|
|
1884
2118
|
kind: z.ZodLiteral<"component">;
|
|
2119
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
2120
|
+
group: z.ZodString;
|
|
2121
|
+
name: z.ZodString;
|
|
2122
|
+
version: z.ZodOptional<z.ZodString>;
|
|
2123
|
+
id: z.ZodString;
|
|
2124
|
+
repo: z.ZodString;
|
|
2125
|
+
commit: z.ZodString;
|
|
2126
|
+
component: z.ZodOptional<z.ZodString>;
|
|
2127
|
+
cite: z.ZodObject<{
|
|
2128
|
+
file: z.ZodString;
|
|
2129
|
+
line: z.ZodNumber;
|
|
2130
|
+
value: z.ZodString;
|
|
2131
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
2132
|
+
with: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
2133
|
+
file: z.ZodString;
|
|
2134
|
+
line: z.ZodNumber;
|
|
2135
|
+
value: z.ZodString;
|
|
2136
|
+
}, z.core.$strict>>>;
|
|
2137
|
+
}, z.core.$strict>;
|
|
2138
|
+
verified: z.ZodDefault<z.ZodEnum<{
|
|
2139
|
+
line: "line";
|
|
2140
|
+
none: "none";
|
|
2141
|
+
person: "person";
|
|
2142
|
+
sample: "sample";
|
|
2143
|
+
}>>;
|
|
2144
|
+
by: z.ZodDefault<z.ZodEnum<{
|
|
2145
|
+
person: "person";
|
|
2146
|
+
assistant: "assistant";
|
|
2147
|
+
reader: "reader";
|
|
2148
|
+
}>>;
|
|
2149
|
+
conf: z.ZodDefault<z.ZodEnum<{
|
|
2150
|
+
inferred: "inferred";
|
|
2151
|
+
declared: "declared";
|
|
2152
|
+
}>>;
|
|
2153
|
+
kind: z.ZodLiteral<"artifact">;
|
|
2154
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
2155
|
+
group: z.ZodString;
|
|
2156
|
+
name: z.ZodString;
|
|
2157
|
+
version: z.ZodOptional<z.ZodString>;
|
|
2158
|
+
scope: z.ZodOptional<z.ZodEnum<{
|
|
2159
|
+
runtime: "runtime";
|
|
2160
|
+
compile: "compile";
|
|
2161
|
+
provided: "provided";
|
|
2162
|
+
test: "test";
|
|
2163
|
+
import: "import";
|
|
2164
|
+
}>>;
|
|
2165
|
+
id: z.ZodString;
|
|
2166
|
+
repo: z.ZodString;
|
|
2167
|
+
commit: z.ZodString;
|
|
2168
|
+
component: z.ZodOptional<z.ZodString>;
|
|
2169
|
+
cite: z.ZodObject<{
|
|
2170
|
+
file: z.ZodString;
|
|
2171
|
+
line: z.ZodNumber;
|
|
2172
|
+
value: z.ZodString;
|
|
2173
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
2174
|
+
with: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
2175
|
+
file: z.ZodString;
|
|
2176
|
+
line: z.ZodNumber;
|
|
2177
|
+
value: z.ZodString;
|
|
2178
|
+
}, z.core.$strict>>>;
|
|
2179
|
+
}, z.core.$strict>;
|
|
2180
|
+
verified: z.ZodDefault<z.ZodEnum<{
|
|
2181
|
+
line: "line";
|
|
2182
|
+
none: "none";
|
|
2183
|
+
person: "person";
|
|
2184
|
+
sample: "sample";
|
|
2185
|
+
}>>;
|
|
2186
|
+
by: z.ZodDefault<z.ZodEnum<{
|
|
2187
|
+
person: "person";
|
|
2188
|
+
assistant: "assistant";
|
|
2189
|
+
reader: "reader";
|
|
2190
|
+
}>>;
|
|
2191
|
+
conf: z.ZodDefault<z.ZodEnum<{
|
|
2192
|
+
inferred: "inferred";
|
|
2193
|
+
declared: "declared";
|
|
2194
|
+
}>>;
|
|
2195
|
+
kind: z.ZodLiteral<"dependency">;
|
|
1885
2196
|
}, z.core.$strict>], "kind">>;
|
|
@@ -63,10 +63,10 @@ export declare const FrameworkClient: z.ZodObject<{
|
|
|
63
63
|
}, z.core.$strict>;
|
|
64
64
|
/** Languages the house-framework extractor reads (js covers JavaScript and TypeScript). */
|
|
65
65
|
export declare const FrameworkLanguage: z.ZodEnum<{
|
|
66
|
-
python: "python";
|
|
67
|
-
go: "go";
|
|
68
66
|
js: "js";
|
|
69
67
|
csharp: "csharp";
|
|
68
|
+
python: "python";
|
|
69
|
+
go: "go";
|
|
70
70
|
}>;
|
|
71
71
|
/** A call that reaches another system (ADR 0055). */
|
|
72
72
|
export declare const FrameworkCall: z.ZodObject<{
|
|
@@ -99,10 +99,10 @@ export declare const FrameworkCall: z.ZodObject<{
|
|
|
99
99
|
receiver: z.ZodOptional<z.ZodString>;
|
|
100
100
|
from: z.ZodOptional<z.ZodString>;
|
|
101
101
|
language: z.ZodOptional<z.ZodEnum<{
|
|
102
|
-
python: "python";
|
|
103
|
-
go: "go";
|
|
104
102
|
js: "js";
|
|
105
103
|
csharp: "csharp";
|
|
104
|
+
python: "python";
|
|
105
|
+
go: "go";
|
|
106
106
|
}>>;
|
|
107
107
|
source: z.ZodObject<{
|
|
108
108
|
kind: z.ZodEnum<{
|
|
@@ -132,10 +132,10 @@ export declare const FrameworkRoute: z.ZodObject<{
|
|
|
132
132
|
receiver: z.ZodOptional<z.ZodString>;
|
|
133
133
|
from: z.ZodOptional<z.ZodString>;
|
|
134
134
|
language: z.ZodOptional<z.ZodEnum<{
|
|
135
|
-
python: "python";
|
|
136
|
-
go: "go";
|
|
137
135
|
js: "js";
|
|
138
136
|
csharp: "csharp";
|
|
137
|
+
python: "python";
|
|
138
|
+
go: "go";
|
|
139
139
|
}>>;
|
|
140
140
|
source: z.ZodObject<{
|
|
141
141
|
kind: z.ZodEnum<{
|
|
@@ -273,10 +273,10 @@ export declare const FrameworkModel: z.ZodObject<{
|
|
|
273
273
|
receiver: z.ZodOptional<z.ZodString>;
|
|
274
274
|
from: z.ZodOptional<z.ZodString>;
|
|
275
275
|
language: z.ZodOptional<z.ZodEnum<{
|
|
276
|
-
python: "python";
|
|
277
|
-
go: "go";
|
|
278
276
|
js: "js";
|
|
279
277
|
csharp: "csharp";
|
|
278
|
+
python: "python";
|
|
279
|
+
go: "go";
|
|
280
280
|
}>>;
|
|
281
281
|
source: z.ZodObject<{
|
|
282
282
|
kind: z.ZodEnum<{
|
|
@@ -305,10 +305,10 @@ export declare const FrameworkModel: z.ZodObject<{
|
|
|
305
305
|
receiver: z.ZodOptional<z.ZodString>;
|
|
306
306
|
from: z.ZodOptional<z.ZodString>;
|
|
307
307
|
language: z.ZodOptional<z.ZodEnum<{
|
|
308
|
-
python: "python";
|
|
309
|
-
go: "go";
|
|
310
308
|
js: "js";
|
|
311
309
|
csharp: "csharp";
|
|
310
|
+
python: "python";
|
|
311
|
+
go: "go";
|
|
312
312
|
}>>;
|
|
313
313
|
source: z.ZodObject<{
|
|
314
314
|
kind: z.ZodEnum<{
|
|
@@ -404,8 +404,8 @@ export declare const FindingEvidence: z.ZodObject<{
|
|
|
404
404
|
export: "export";
|
|
405
405
|
manual: "manual";
|
|
406
406
|
}>, z.ZodEnum<{
|
|
407
|
-
catalog: "catalog";
|
|
408
407
|
artifact: "artifact";
|
|
408
|
+
catalog: "catalog";
|
|
409
409
|
rule: "rule";
|
|
410
410
|
}>]>;
|
|
411
411
|
record: z.ZodOptional<z.ZodString>;
|
|
@@ -510,8 +510,8 @@ export declare const Finding: z.ZodObject<{
|
|
|
510
510
|
export: "export";
|
|
511
511
|
manual: "manual";
|
|
512
512
|
}>, z.ZodEnum<{
|
|
513
|
-
catalog: "catalog";
|
|
514
513
|
artifact: "artifact";
|
|
514
|
+
catalog: "catalog";
|
|
515
515
|
rule: "rule";
|
|
516
516
|
}>]>;
|
|
517
517
|
record: z.ZodOptional<z.ZodString>;
|