@goodbones/campaigns 0.1.0

package/build/dts/domain/config.d.ts

@@ -0,0 +1,985 @@
+import * as Schema from "effect/Schema";
+export declare const CampaignUnit: Schema.Literals<readonly ["file", "declaration", "match"]>;
+export declare const Holdout: Schema.Literals<readonly ["file", "declaration", "match", "sector"]>;
+declare const PathTerm: Schema.Struct<{
+    readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+    readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+    readonly subject: Schema.optionalKey<Schema.Finite>;
+    readonly convention: Schema.optionalKey<Schema.String>;
+}>;
+export type PathTerm = (typeof PathTerm)["Type"];
+declare const ImportsTerm: Schema.Struct<{
+    readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly external: Schema.String;
+    }>, Schema.Struct<{
+        readonly builtin: Schema.String;
+    }>]>;
+    readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+export type ImportsTerm = (typeof ImportsTerm)["Type"];
+declare const ExportsTerm: Schema.Struct<{
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+    readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+    readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+    readonly reexport: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type ExportsTerm = (typeof ExportsTerm)["Type"];
+declare const MembersTerm: Schema.Struct<{
+    readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+    readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+    readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+}>;
+export type MembersTerm = (typeof MembersTerm)["Type"];
+declare const ContentTerm: Schema.Struct<{
+    readonly regex: Schema.String;
+}>;
+type ContentTerm = (typeof ContentTerm)["Type"];
+declare const CaptureNarrowing: Schema.Struct<{
+    readonly regex: Schema.optionalKey<Schema.String>;
+    readonly binding: Schema.optionalKey<Schema.Struct<{
+        readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly external: Schema.String;
+        }>, Schema.Struct<{
+            readonly builtin: Schema.String;
+        }>]>;
+        readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>;
+}>;
+declare const SyntaxTerm: Schema.Struct<{
+    readonly rule: Schema.Unknown;
+    readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly regex: Schema.optionalKey<Schema.String>;
+        readonly binding: Schema.optionalKey<Schema.Struct<{
+            readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly external: Schema.String;
+            }>, Schema.Struct<{
+                readonly builtin: Schema.String;
+            }>]>;
+            readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>>;
+    }>>>;
+}>;
+export type SyntaxTerm = (typeof SyntaxTerm)["Type"];
+export declare const ReportFormat: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+declare const ReportTerm: Schema.Struct<{
+    readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+    readonly pattern: Schema.optionalKey<Schema.String>;
+    readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+export type ReportTerm = (typeof ReportTerm)["Type"];
+export type Detector = {
+    readonly all: ReadonlyArray<Detector>;
+} | {
+    readonly any: ReadonlyArray<Detector>;
+} | {
+    readonly not: Detector;
+} | {
+    readonly path: PathTerm;
+} | {
+    readonly imports: ImportsTerm;
+} | {
+    readonly exports: ExportsTerm;
+} | {
+    readonly members: MembersTerm;
+} | {
+    readonly requires: ReadonlyArray<string>;
+} | {
+    readonly content: ContentTerm;
+} | {
+    readonly syntax: SyntaxTerm;
+} | {
+    readonly report: ReportTerm;
+} | {
+    readonly fn: string;
+};
+export declare const Detector: Schema.Union<readonly [Schema.Struct<{
+    readonly all: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+}>, Schema.Struct<{
+    readonly any: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+}>, Schema.Struct<{
+    readonly not: Schema.suspend<Schema.Codec<Detector, Detector, never, never>>;
+}>, Schema.Struct<{
+    readonly path: Schema.Struct<{
+        readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+        readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+        readonly subject: Schema.optionalKey<Schema.Finite>;
+        readonly convention: Schema.optionalKey<Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly imports: Schema.Struct<{
+        readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly external: Schema.String;
+        }>, Schema.Struct<{
+            readonly builtin: Schema.String;
+        }>]>;
+        readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>;
+}>, Schema.Struct<{
+    readonly exports: Schema.Struct<{
+        readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+        readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+        readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+        readonly reexport: Schema.optionalKey<Schema.Boolean>;
+    }>;
+}>, Schema.Struct<{
+    readonly members: Schema.Struct<{
+        readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+        readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+        readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+        readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+    }>;
+}>, Schema.Struct<{
+    readonly requires: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly content: Schema.Struct<{
+        readonly regex: Schema.String;
+    }>;
+}>, Schema.Struct<{
+    readonly syntax: Schema.Struct<{
+        readonly rule: Schema.Unknown;
+        readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly regex: Schema.optionalKey<Schema.String>;
+            readonly binding: Schema.optionalKey<Schema.Struct<{
+                readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly external: Schema.String;
+                }>, Schema.Struct<{
+                    readonly builtin: Schema.String;
+                }>]>;
+                readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>>;
+        }>>>;
+    }>;
+}>, Schema.Struct<{
+    readonly report: Schema.Struct<{
+        readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+        readonly pattern: Schema.optionalKey<Schema.String>;
+        readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>;
+}>, Schema.Struct<{
+    readonly fn: Schema.String;
+}>]>;
+export declare const SectorTerm: Schema.Union<readonly [Schema.Struct<{
+    readonly has: Schema.Union<readonly [Schema.Struct<{
+        readonly all: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+    }>, Schema.Struct<{
+        readonly any: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+    }>, Schema.Struct<{
+        readonly not: Schema.suspend<Schema.Codec<Detector, Detector, never, never>>;
+    }>, Schema.Struct<{
+        readonly path: Schema.Struct<{
+            readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+            readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly subject: Schema.optionalKey<Schema.Finite>;
+            readonly convention: Schema.optionalKey<Schema.String>;
+        }>;
+    }>, Schema.Struct<{
+        readonly imports: Schema.Struct<{
+            readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly external: Schema.String;
+            }>, Schema.Struct<{
+                readonly builtin: Schema.String;
+            }>]>;
+            readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly exports: Schema.Struct<{
+            readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+            readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+            readonly reexport: Schema.optionalKey<Schema.Boolean>;
+        }>;
+    }>, Schema.Struct<{
+        readonly members: Schema.Struct<{
+            readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+            readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly requires: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly content: Schema.Struct<{
+            readonly regex: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly syntax: Schema.Struct<{
+            readonly rule: Schema.Unknown;
+            readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly regex: Schema.optionalKey<Schema.String>;
+                readonly binding: Schema.optionalKey<Schema.Struct<{
+                    readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly external: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly builtin: Schema.String;
+                    }>]>;
+                    readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>>;
+            }>>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly report: Schema.Struct<{
+            readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+            readonly pattern: Schema.optionalKey<Schema.String>;
+            readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly fn: Schema.String;
+    }>]>;
+}>, Schema.Struct<{
+    readonly oneRoot: Schema.Literal<true>;
+}>, Schema.Struct<{
+    readonly oneHost: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+}>]>;
+export type SectorTerm = (typeof SectorTerm)["Type"];
+export declare const ProbeDiagnostic: Schema.Struct<{
+    readonly line: Schema.Finite;
+    readonly column: Schema.optionalKey<Schema.Finite>;
+    readonly code: Schema.optionalKey<Schema.String>;
+    readonly message: Schema.optionalKey<Schema.String>;
+}>;
+export declare const CampaignProbe: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly source: Schema.optionalKey<Schema.String>;
+    readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly external: Schema.String;
+    }>, Schema.Struct<{
+        readonly builtin: Schema.String;
+    }>]>>>;
+    readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly line: Schema.Finite;
+        readonly column: Schema.optionalKey<Schema.Finite>;
+        readonly code: Schema.optionalKey<Schema.String>;
+        readonly message: Schema.optionalKey<Schema.String>;
+    }>>>;
+}>;
+export declare const CampaignProbes: Schema.Struct<{
+    readonly fires: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly source: Schema.optionalKey<Schema.String>;
+        readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly external: Schema.String;
+        }>, Schema.Struct<{
+            readonly builtin: Schema.String;
+        }>]>>>;
+        readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly line: Schema.Finite;
+            readonly column: Schema.optionalKey<Schema.Finite>;
+            readonly code: Schema.optionalKey<Schema.String>;
+            readonly message: Schema.optionalKey<Schema.String>;
+        }>>>;
+    }>>;
+    readonly ignores: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly source: Schema.optionalKey<Schema.String>;
+        readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly external: Schema.String;
+        }>, Schema.Struct<{
+            readonly builtin: Schema.String;
+        }>]>>>;
+        readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly line: Schema.Finite;
+            readonly column: Schema.optionalKey<Schema.Finite>;
+            readonly code: Schema.optionalKey<Schema.String>;
+            readonly message: Schema.optionalKey<Schema.String>;
+        }>>>;
+    }>>;
+}>;
+export declare const ObjectiveRule: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly id: Schema.String;
+    readonly campaign: Schema.String;
+    readonly message: Schema.String;
+    readonly why: Schema.optionalKey<Schema.String>;
+    readonly holdout: Schema.Literals<readonly ["file", "declaration", "match", "sector"]>;
+    readonly match: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly all: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+    }>, Schema.Struct<{
+        readonly any: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+    }>, Schema.Struct<{
+        readonly not: Schema.suspend<Schema.Codec<Detector, Detector, never, never>>;
+    }>, Schema.Struct<{
+        readonly path: Schema.Struct<{
+            readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+            readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly subject: Schema.optionalKey<Schema.Finite>;
+            readonly convention: Schema.optionalKey<Schema.String>;
+        }>;
+    }>, Schema.Struct<{
+        readonly imports: Schema.Struct<{
+            readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly external: Schema.String;
+            }>, Schema.Struct<{
+                readonly builtin: Schema.String;
+            }>]>;
+            readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly exports: Schema.Struct<{
+            readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+            readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+            readonly reexport: Schema.optionalKey<Schema.Boolean>;
+        }>;
+    }>, Schema.Struct<{
+        readonly members: Schema.Struct<{
+            readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+            readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly requires: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly content: Schema.Struct<{
+            readonly regex: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly syntax: Schema.Struct<{
+            readonly rule: Schema.Unknown;
+            readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly regex: Schema.optionalKey<Schema.String>;
+                readonly binding: Schema.optionalKey<Schema.Struct<{
+                    readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly external: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly builtin: Schema.String;
+                    }>]>;
+                    readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>>;
+            }>>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly report: Schema.Struct<{
+            readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+            readonly pattern: Schema.optionalKey<Schema.String>;
+            readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly fn: Schema.String;
+    }>]>>;
+    readonly sector: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly has: Schema.Union<readonly [Schema.Struct<{
+            readonly all: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+        }>, Schema.Struct<{
+            readonly any: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+        }>, Schema.Struct<{
+            readonly not: Schema.suspend<Schema.Codec<Detector, Detector, never, never>>;
+        }>, Schema.Struct<{
+            readonly path: Schema.Struct<{
+                readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+                readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly subject: Schema.optionalKey<Schema.Finite>;
+                readonly convention: Schema.optionalKey<Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            readonly imports: Schema.Struct<{
+                readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly external: Schema.String;
+                }>, Schema.Struct<{
+                    readonly builtin: Schema.String;
+                }>]>;
+                readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly exports: Schema.Struct<{
+                readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+                readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+                readonly reexport: Schema.optionalKey<Schema.Boolean>;
+            }>;
+        }>, Schema.Struct<{
+            readonly members: Schema.Struct<{
+                readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+                readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly requires: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly content: Schema.Struct<{
+                readonly regex: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly syntax: Schema.Struct<{
+                readonly rule: Schema.Unknown;
+                readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly regex: Schema.optionalKey<Schema.String>;
+                    readonly binding: Schema.optionalKey<Schema.Struct<{
+                        readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly external: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly builtin: Schema.String;
+                        }>]>;
+                        readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    }>>;
+                }>>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly report: Schema.Struct<{
+                readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+                readonly pattern: Schema.optionalKey<Schema.String>;
+                readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly fn: Schema.String;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly oneRoot: Schema.Literal<true>;
+    }>, Schema.Struct<{
+        readonly oneHost: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+    }>]>>;
+    readonly endState: Schema.optionalKey<Schema.Struct<{
+        readonly phase: Schema.String;
+        readonly family: Schema.Literals<readonly ["imports", "exports", "members", "surface", "structure"]>;
+    }>>;
+    readonly until: Schema.optionalKey<Schema.String>;
+    readonly probes: Schema.Struct<{
+        readonly fires: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly source: Schema.optionalKey<Schema.String>;
+            readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly external: Schema.String;
+            }>, Schema.Struct<{
+                readonly builtin: Schema.String;
+            }>]>>>;
+            readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly line: Schema.Finite;
+                readonly column: Schema.optionalKey<Schema.Finite>;
+                readonly code: Schema.optionalKey<Schema.String>;
+                readonly message: Schema.optionalKey<Schema.String>;
+            }>>>;
+        }>>;
+        readonly ignores: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly source: Schema.optionalKey<Schema.String>;
+            readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly external: Schema.String;
+            }>, Schema.Struct<{
+                readonly builtin: Schema.String;
+            }>]>>>;
+            readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly line: Schema.Finite;
+                readonly column: Schema.optionalKey<Schema.Finite>;
+                readonly code: Schema.optionalKey<Schema.String>;
+                readonly message: Schema.optionalKey<Schema.String>;
+            }>>>;
+        }>>;
+    }>;
+}>;
+export declare const PerimeterRule: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"file">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"nx">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"glob">;
+    readonly glob: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"marker">;
+    readonly marker: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+    readonly probes: Schema.optionalKey<Schema.Struct<{
+        readonly fires: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+        readonly ignores: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"match">;
+    readonly match: Schema.Union<readonly [Schema.Struct<{
+        readonly all: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+    }>, Schema.Struct<{
+        readonly any: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+    }>, Schema.Struct<{
+        readonly not: Schema.suspend<Schema.Codec<Detector, Detector, never, never>>;
+    }>, Schema.Struct<{
+        readonly path: Schema.Struct<{
+            readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+            readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly subject: Schema.optionalKey<Schema.Finite>;
+            readonly convention: Schema.optionalKey<Schema.String>;
+        }>;
+    }>, Schema.Struct<{
+        readonly imports: Schema.Struct<{
+            readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly external: Schema.String;
+            }>, Schema.Struct<{
+                readonly builtin: Schema.String;
+            }>]>;
+            readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly exports: Schema.Struct<{
+            readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+            readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+            readonly reexport: Schema.optionalKey<Schema.Boolean>;
+        }>;
+    }>, Schema.Struct<{
+        readonly members: Schema.Struct<{
+            readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+            readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+            readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly requires: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly content: Schema.Struct<{
+            readonly regex: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly syntax: Schema.Struct<{
+            readonly rule: Schema.Unknown;
+            readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly regex: Schema.optionalKey<Schema.String>;
+                readonly binding: Schema.optionalKey<Schema.Struct<{
+                    readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly external: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly builtin: Schema.String;
+                    }>]>;
+                    readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>>;
+            }>>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly report: Schema.Struct<{
+            readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+            readonly pattern: Schema.optionalKey<Schema.String>;
+            readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly fn: Schema.String;
+    }>]>;
+    readonly unit: Schema.Literals<readonly ["declaration", "match"]>;
+    readonly probes: Schema.Struct<{
+        readonly fires: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly source: Schema.optionalKey<Schema.String>;
+            readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly external: Schema.String;
+            }>, Schema.Struct<{
+                readonly builtin: Schema.String;
+            }>]>>>;
+            readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly line: Schema.Finite;
+                readonly column: Schema.optionalKey<Schema.Finite>;
+                readonly code: Schema.optionalKey<Schema.String>;
+                readonly message: Schema.optionalKey<Schema.String>;
+            }>>>;
+        }>>;
+        readonly ignores: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly source: Schema.optionalKey<Schema.String>;
+            readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly external: Schema.String;
+            }>, Schema.Struct<{
+                readonly builtin: Schema.String;
+            }>]>>>;
+            readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly line: Schema.Finite;
+                readonly column: Schema.optionalKey<Schema.Finite>;
+                readonly code: Schema.optionalKey<Schema.String>;
+                readonly message: Schema.optionalKey<Schema.String>;
+            }>>>;
+        }>>;
+    }>;
+}>]>;
+export type PerimeterRule = (typeof PerimeterRule)["Type"];
+export declare const OnTouch: Schema.Literals<readonly ["advise", "ratchet", "paydown"]>;
+export type OnTouch = (typeof OnTouch)["Type"];
+export declare const PhaseConcession: Schema.Struct<{
+    readonly reason: Schema.String;
+    readonly at: Schema.String;
+    readonly by: Schema.optionalKey<Schema.String>;
+}>;
+export declare const PhaseRule: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly intent: Schema.optionalKey<Schema.String>;
+    readonly objectives: Schema.$Array<Schema.String>;
+    readonly attested: Schema.Boolean;
+    readonly onTouch: Schema.optionalKey<Schema.Literals<readonly ["advise", "ratchet", "paydown"]>>;
+    readonly endState: Schema.optionalKey<Schema.Unknown>;
+    readonly concessions: Schema.$Array<Schema.Struct<{
+        readonly reason: Schema.String;
+        readonly at: Schema.String;
+        readonly by: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly hash: Schema.String;
+}>;
+export type PhaseRule = (typeof PhaseRule)["Type"];
+export declare const CampaignRule: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly id: Schema.String;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly why: Schema.optionalKey<Schema.String>;
+    readonly owner: Schema.optionalKey<Schema.String>;
+    readonly scope: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+    readonly extensions: Schema.$Array<Schema.String>;
+    readonly legacy: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+    readonly perimeter: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"file">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"nx">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"glob">;
+        readonly glob: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"marker">;
+        readonly marker: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+        readonly probes: Schema.optionalKey<Schema.Struct<{
+            readonly fires: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+            readonly ignores: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"match">;
+        readonly match: Schema.Union<readonly [Schema.Struct<{
+            readonly all: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+        }>, Schema.Struct<{
+            readonly any: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+        }>, Schema.Struct<{
+            readonly not: Schema.suspend<Schema.Codec<Detector, Detector, never, never>>;
+        }>, Schema.Struct<{
+            readonly path: Schema.Struct<{
+                readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+                readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly subject: Schema.optionalKey<Schema.Finite>;
+                readonly convention: Schema.optionalKey<Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            readonly imports: Schema.Struct<{
+                readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly external: Schema.String;
+                }>, Schema.Struct<{
+                    readonly builtin: Schema.String;
+                }>]>;
+                readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly exports: Schema.Struct<{
+                readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+                readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+                readonly reexport: Schema.optionalKey<Schema.Boolean>;
+            }>;
+        }>, Schema.Struct<{
+            readonly members: Schema.Struct<{
+                readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+                readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly requires: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly content: Schema.Struct<{
+                readonly regex: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly syntax: Schema.Struct<{
+                readonly rule: Schema.Unknown;
+                readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly regex: Schema.optionalKey<Schema.String>;
+                    readonly binding: Schema.optionalKey<Schema.Struct<{
+                        readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly external: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly builtin: Schema.String;
+                        }>]>;
+                        readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    }>>;
+                }>>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly report: Schema.Struct<{
+                readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+                readonly pattern: Schema.optionalKey<Schema.String>;
+                readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly fn: Schema.String;
+        }>]>;
+        readonly unit: Schema.Literals<readonly ["declaration", "match"]>;
+        readonly probes: Schema.Struct<{
+            readonly fires: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly source: Schema.optionalKey<Schema.String>;
+                readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly external: Schema.String;
+                }>, Schema.Struct<{
+                    readonly builtin: Schema.String;
+                }>]>>>;
+                readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Finite;
+                    readonly column: Schema.optionalKey<Schema.Finite>;
+                    readonly code: Schema.optionalKey<Schema.String>;
+                    readonly message: Schema.optionalKey<Schema.String>;
+                }>>>;
+            }>>;
+            readonly ignores: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly source: Schema.optionalKey<Schema.String>;
+                readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly external: Schema.String;
+                }>, Schema.Struct<{
+                    readonly builtin: Schema.String;
+                }>]>>>;
+                readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Finite;
+                    readonly column: Schema.optionalKey<Schema.Finite>;
+                    readonly code: Schema.optionalKey<Schema.String>;
+                    readonly message: Schema.optionalKey<Schema.String>;
+                }>>>;
+            }>>;
+        }>;
+    }>]>>;
+    readonly onTouch: Schema.optionalKey<Schema.Literals<readonly ["advise", "ratchet", "paydown"]>>;
+    readonly phases: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly intent: Schema.optionalKey<Schema.String>;
+        readonly objectives: Schema.$Array<Schema.String>;
+        readonly attested: Schema.Boolean;
+        readonly onTouch: Schema.optionalKey<Schema.Literals<readonly ["advise", "ratchet", "paydown"]>>;
+        readonly endState: Schema.optionalKey<Schema.Unknown>;
+        readonly concessions: Schema.$Array<Schema.Struct<{
+            readonly reason: Schema.String;
+            readonly at: Schema.String;
+            readonly by: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly hash: Schema.String;
+    }>>;
+    readonly objectives: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly id: Schema.String;
+        readonly campaign: Schema.String;
+        readonly message: Schema.String;
+        readonly why: Schema.optionalKey<Schema.String>;
+        readonly holdout: Schema.Literals<readonly ["file", "declaration", "match", "sector"]>;
+        readonly match: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly all: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+        }>, Schema.Struct<{
+            readonly any: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+        }>, Schema.Struct<{
+            readonly not: Schema.suspend<Schema.Codec<Detector, Detector, never, never>>;
+        }>, Schema.Struct<{
+            readonly path: Schema.Struct<{
+                readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+                readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly subject: Schema.optionalKey<Schema.Finite>;
+                readonly convention: Schema.optionalKey<Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            readonly imports: Schema.Struct<{
+                readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly external: Schema.String;
+                }>, Schema.Struct<{
+                    readonly builtin: Schema.String;
+                }>]>;
+                readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly exports: Schema.Struct<{
+                readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+                readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+                readonly reexport: Schema.optionalKey<Schema.Boolean>;
+            }>;
+        }>, Schema.Struct<{
+            readonly members: Schema.Struct<{
+                readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+                readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly requires: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly content: Schema.Struct<{
+                readonly regex: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly syntax: Schema.Struct<{
+                readonly rule: Schema.Unknown;
+                readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly regex: Schema.optionalKey<Schema.String>;
+                    readonly binding: Schema.optionalKey<Schema.Struct<{
+                        readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly external: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly builtin: Schema.String;
+                        }>]>;
+                        readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    }>>;
+                }>>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly report: Schema.Struct<{
+                readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+                readonly pattern: Schema.optionalKey<Schema.String>;
+                readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly fn: Schema.String;
+        }>]>>;
+        readonly sector: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly has: Schema.Union<readonly [Schema.Struct<{
+                readonly all: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+            }>, Schema.Struct<{
+                readonly any: Schema.$Array<Schema.suspend<Schema.Codec<Detector, Detector, never, never>>>;
+            }>, Schema.Struct<{
+                readonly not: Schema.suspend<Schema.Codec<Detector, Detector, never, never>>;
+            }>, Schema.Struct<{
+                readonly path: Schema.Struct<{
+                    readonly file: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+                    readonly fileNot: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                    readonly subject: Schema.optionalKey<Schema.Finite>;
+                    readonly convention: Schema.optionalKey<Schema.String>;
+                }>;
+            }>, Schema.Struct<{
+                readonly imports: Schema.Struct<{
+                    readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly external: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly builtin: Schema.String;
+                    }>]>;
+                    readonly symbols: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>;
+            }>, Schema.Struct<{
+                readonly exports: Schema.Struct<{
+                    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                    readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["named", "default", "namespace"]>>>;
+                    readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+                    readonly reexport: Schema.optionalKey<Schema.Boolean>;
+                }>;
+            }>, Schema.Struct<{
+                readonly members: Schema.Struct<{
+                    readonly subject: Schema.Literals<readonly ["members", "calls"]>;
+                    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                    readonly in: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+                    readonly declares: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["function", "class", "variable", "type", "interface", "enum", "expression", "other"]>>>;
+                }>;
+            }>, Schema.Struct<{
+                readonly requires: Schema.$Array<Schema.String>;
+            }>, Schema.Struct<{
+                readonly content: Schema.Struct<{
+                    readonly regex: Schema.String;
+                }>;
+            }>, Schema.Struct<{
+                readonly syntax: Schema.Struct<{
+                    readonly rule: Schema.Unknown;
+                    readonly where: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                        readonly regex: Schema.optionalKey<Schema.String>;
+                        readonly binding: Schema.optionalKey<Schema.Struct<{
+                            readonly resolves: Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly external: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly builtin: Schema.String;
+                            }>]>;
+                            readonly member: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        }>>;
+                    }>>>;
+                }>;
+            }>, Schema.Struct<{
+                readonly report: Schema.Struct<{
+                    readonly command: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly file: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly format: Schema.Literals<readonly ["tsc", "eslint", "oxlint", "regex"]>;
+                    readonly pattern: Schema.optionalKey<Schema.String>;
+                    readonly codes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly codesNot: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>;
+            }>, Schema.Struct<{
+                readonly fn: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly oneRoot: Schema.Literal<true>;
+        }>, Schema.Struct<{
+            readonly oneHost: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+        }>]>>;
+        readonly endState: Schema.optionalKey<Schema.Struct<{
+            readonly phase: Schema.String;
+            readonly family: Schema.Literals<readonly ["imports", "exports", "members", "surface", "structure"]>;
+        }>>;
+        readonly until: Schema.optionalKey<Schema.String>;
+        readonly probes: Schema.Struct<{
+            readonly fires: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly source: Schema.optionalKey<Schema.String>;
+                readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly external: Schema.String;
+                }>, Schema.Struct<{
+                    readonly builtin: Schema.String;
+                }>]>>>;
+                readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Finite;
+                    readonly column: Schema.optionalKey<Schema.Finite>;
+                    readonly code: Schema.optionalKey<Schema.String>;
+                    readonly message: Schema.optionalKey<Schema.String>;
+                }>>>;
+            }>>;
+            readonly ignores: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly source: Schema.optionalKey<Schema.String>;
+                readonly edges: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly external: Schema.String;
+                }>, Schema.Struct<{
+                    readonly builtin: Schema.String;
+                }>]>>>;
+                readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly report: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Finite;
+                    readonly column: Schema.optionalKey<Schema.Finite>;
+                    readonly code: Schema.optionalKey<Schema.String>;
+                    readonly message: Schema.optionalKey<Schema.String>;
+                }>>>;
+            }>>;
+        }>;
+    }>>;
+    readonly staleAfter: Schema.optionalKey<Schema.Finite>;
+    readonly onComplete: Schema.Literals<readonly ["keep", "remove"]>;
+}>;
+export type CampaignUnit = (typeof CampaignUnit)["Type"];
+export type Holdout = (typeof Holdout)["Type"];
+export type CampaignProbe = (typeof CampaignProbe)["Type"];
+export type CampaignProbes = (typeof CampaignProbes)["Type"];
+export type ProbeDiagnostic = (typeof ProbeDiagnostic)["Type"];
+export type ReportFormat = (typeof ReportFormat)["Type"];
+export type ObjectiveRule = (typeof ObjectiveRule)["Type"];
+export type PhaseConcession = (typeof PhaseConcession)["Type"];
+export type CampaignRule = (typeof CampaignRule)["Type"];
+export type CaptureNarrowing = (typeof CaptureNarrowing)["Type"];
+export {};
+//# sourceMappingURL=config.d.ts.map