@alveolus/arch 0.1.0-alpha.0 → 0.2.0

package/dist/index.d.mts

@@ -1,256 +1,540 @@
 import { Project } from "ts-morph";
-//#region src/codebase/core-api.d.ts
-type CoreKind = "AggregateRoot" | "Entity" | "ValueObject" | "Identifier" | "DomainEvent" | "DomainError" | "DomainService" | "Port" | "CommandRepository" | "QueryRepository" | "CommandHandler" | "QueryHandler" | "EventTranslator" | "EventPublisher" | "Outbox" | "UnitOfWork";
-type CoreMarker = "OpenHostService" | "AntiCorruptionLayer";
+//#region src/architecture/allowed-packages.d.ts
+type PackageDependencies = Readonly<Record<string, true | readonly string[]>>;
+export declare class AllowedPackages {
+  private readonly packages;
+  constructor(packages?: PackageDependencies);
+  has(packageName: string): boolean;
+  forbiddenNames(packageName: string, names: readonly string[]): readonly string[];
+  allowedNames(packageName: string): readonly string[];
+  with(other: AllowedPackages): AllowedPackages;
+}
+//#endregion
+//#region src/conventions/core-api.d.ts
+declare const coreKinds: readonly ["AggregateRoot", "Entity", "ValueObject", "Identifier", "DomainEvent", "DomainError", "DomainService", "Port", "CommandRepository", "QueryRepository", "CommandHandler", "QueryHandler", "EventTranslator", "EventPublisher", "Outbox", "UnitOfWork"];
+type CoreKind = (typeof coreKinds)[number];
+declare const coreMarkers: readonly ["OpenHostService", "AntiCorruptionLayer"];
+type CoreMarker = (typeof coreMarkers)[number];
+//#endregion
+//#region src/conventions/layers.d.ts
+declare const layers: readonly ["domain", "application", "published-language", "driven", "driving"];
+type Layer = (typeof layers)[number];
+//#endregion
+//#region src/conventions/building-blocks.d.ts
+interface PlaceSpec {
+  readonly layer: Layer;
+  readonly folder?: string;
+  readonly suffix?: string;
+}
 //#endregion
-//#region src/codebase/method.d.ts
-declare class Method {
+//#region src/model/classes/named-type.d.ts
+interface NamedType {
   readonly name: string;
+  readonly packageName: string | undefined;
+}
+//#endregion
+//#region src/model/classes/class-type.d.ts
+declare class ClassType {
+  readonly name: string;
+  readonly declaredIn: string | undefined;
+  readonly lineage: readonly NamedType[];
+  constructor(name: string, declaredIn: string | undefined, lineage: readonly NamedType[]);
+  get key(): string;
+  get isInstalled(): boolean;
+}
+//#endregion
+//#region src/model/classes/heritage.d.ts
+interface TypeArgument {
+  readonly parameter: string;
   readonly line: number;
-  readonly returnsResult: boolean;
-  constructor(name: string, line: number, returnsResult: boolean);
+  readonly types: readonly ClassType[];
+}
+interface Heritage {
+  readonly isByName: boolean;
+  readonly typeArguments: readonly TypeArgument[];
 }
 //#endregion
-//#region src/codebase/type-usage.d.ts
-declare class TypeUsage {
-  readonly member: string;
+//#region src/model/classes/return-shape.d.ts
+interface ReturnShape {
+  readonly alias: NamedType | undefined;
+  readonly union: readonly NamedType[];
+}
+//#endregion
+//#region src/model/classes/member.d.ts
+type MemberKind = "field" | "constructor parameter" | "method" | "getter" | "setter";
+type Visibility = "public" | "protected" | "private";
+interface MemberProps {
+  readonly name: string;
+  readonly line: number;
+  readonly kind: MemberKind;
+  readonly visibility: Visibility;
+  readonly isStatic: boolean;
+  readonly isParameterProperty: boolean;
+  readonly isCallable: boolean;
+  readonly valueTypes: readonly ClassType[];
+  readonly parameterTypes: readonly ClassType[];
+  readonly returns: ReturnShape | undefined;
+}
+declare class Member {
+  readonly name: string;
   readonly line: number;
-  readonly typeName: string;
-  private readonly kinds;
-  constructor(member: string, line: number, typeName: string, kinds: readonly CoreKind[]);
-  is(kind: CoreKind): boolean;
+  readonly kind: MemberKind;
+  readonly visibility: Visibility;
+  readonly isStatic: boolean;
+  readonly isParameterProperty: boolean;
+  readonly isCallable: boolean;
+  readonly valueTypes: readonly ClassType[];
+  readonly parameterTypes: readonly ClassType[];
+  readonly returns: ReturnShape | undefined;
+  constructor(props: MemberProps);
+  get isPublicInstance(): boolean;
+  get isField(): boolean;
 }
 //#endregion
-//#region src/codebase/code-class.d.ts
-interface CodeClassProps {
+//#region src/model/classes/class-declaration.d.ts
+interface ClassDeclarationProps {
   readonly name: string;
   readonly line: number;
   readonly isAbstract: boolean;
-  readonly kinds: readonly CoreKind[];
-  readonly markers: readonly CoreMarker[];
-  readonly constructorParameters: readonly TypeUsage[];
-  readonly fields: readonly TypeUsage[];
-  readonly publicMethods: readonly Method[];
+  readonly type: ClassType;
+  readonly heritage: Heritage | undefined;
+  readonly implemented: readonly NamedType[];
+  readonly members: readonly Member[];
 }
-declare class CodeClass {
+declare class ClassDeclaration {
   readonly name: string;
   readonly line: number;
   readonly isAbstract: boolean;
-  readonly constructorParameters: readonly TypeUsage[];
-  readonly fields: readonly TypeUsage[];
-  readonly publicMethods: readonly Method[];
-  private readonly kinds;
-  private readonly markers;
-  constructor(props: CodeClassProps);
-  is(kind: CoreKind): boolean;
-  implements(marker: CoreMarker): boolean;
-  get extendsBuildingBlock(): boolean;
-  get hasMarker(): boolean;
-}
-//#endregion
-//#region src/codebase/declaration.d.ts
-type DeclarationKind = "function" | "enum";
-declare class Declaration {
-  readonly kind: DeclarationKind;
+  readonly type: ClassType;
+  readonly heritage: Heritage | undefined;
+  readonly implemented: readonly NamedType[];
+  readonly members: readonly Member[];
+  constructor(props: ClassDeclarationProps);
+  get heldMembers(): Member[];
+  get publicSurface(): Member[];
+  get typeArguments(): readonly TypeArgument[];
+  get extendsByName(): boolean;
+  get isStaticOnly(): boolean;
+  private isDeclared;
+}
+//#endregion
+//#region src/model/dependencies/dependency.d.ts
+type DependencyForm = "import" | "re-export" | "inline type" | "dynamic import" | "require" | "global";
+type TargetVisibility = "analysed" | "ignored" | "unresolved";
+type DependencyTarget = {
+  readonly kind: "file";
+  readonly path: string;
+  readonly visibility: TargetVisibility;
+} | {
+  readonly kind: "package";
   readonly name: string;
+};
+declare class Dependency {
+  readonly line: number;
+  readonly form: DependencyForm;
+  readonly specifier: string;
+  readonly names: readonly string[];
+  readonly target: DependencyTarget;
+  constructor(line: number, form: DependencyForm, specifier: string, names: readonly string[], target: DependencyTarget);
+  get label(): string;
+  isOnPackage(name: string): boolean;
+}
+//#endregion
+//#region src/model/dependencies/global-use.d.ts
+type GlobalOrigin = "ecmascript" | "host";
+type GlobalEffect = "clock" | "randomness";
+declare class GlobalUse {
+  readonly line: number;
+  readonly name: string;
+  readonly origin: GlobalOrigin;
+  readonly effect: GlobalEffect | undefined;
+  constructor(line: number, name: string, origin: GlobalOrigin, effect: GlobalEffect | undefined);
+}
+//#endregion
+//#region src/model/statements/disable-comment.d.ts
+declare class DisableComment {
   readonly line: number;
-  constructor(kind: DeclarationKind, name: string, line: number);
+  readonly text: string;
+  constructor(line: number, text: string);
+  get target(): number;
+}
+//#endregion
+//#region src/model/statements/throw.d.ts
+type ThrowForm = "throw" | "Promise.reject";
+declare class Throw {
+  readonly line: number;
+  readonly form: ThrowForm;
+  constructor(line: number, form: ThrowForm);
+}
+//#endregion
+//#region src/model/statements/top-level-statement.d.ts
+type StatementKind = "function" | "enum" | "namespace" | "mutable variable" | "computed constant" | "class expression" | "statement";
+declare class TopLevelStatement {
+  readonly kind: StatementKind;
+  readonly name: string;
+  readonly line: number;
+  constructor(kind: StatementKind, name: string, line: number);
+}
+//#endregion
+//#region src/model/source-file.d.ts
+interface SourceFileProps {
+  readonly path: string;
+  readonly text: string;
+  readonly dependencies: readonly Dependency[];
+  readonly classes: readonly ClassDeclaration[];
+  readonly statements: readonly TopLevelStatement[];
+  readonly throws: readonly Throw[];
+  readonly globals: readonly GlobalUse[];
+  readonly disables: readonly DisableComment[];
+}
+declare class SourceFile {
+  readonly path: string;
+  readonly dependencies: readonly Dependency[];
+  readonly classes: readonly ClassDeclaration[];
+  readonly statements: readonly TopLevelStatement[];
+  readonly throws: readonly Throw[];
+  readonly globals: readonly GlobalUse[];
+  readonly disables: readonly DisableComment[];
+  private readonly lines;
+  constructor(props: SourceFileProps);
+  lineText(line: number): string;
+  disableAbove(line: number): DisableComment | undefined;
+  classNamed(name: string): ClassDeclaration | undefined;
 }
 //#endregion
-//#region src/codebase/location.d.ts
-type Layer = "domain" | "application" | "published-language" | "driven" | "driving";
+//#region src/model/project.d.ts
+declare class Project$1 {
+  readonly directory: string;
+  readonly files: readonly SourceFile[];
+  private readonly filesByPath;
+  constructor(directory: string, files: readonly SourceFile[]);
+  file(path: string): SourceFile | undefined;
+  classOf(type: ClassType): ClassDeclaration | undefined;
+  relativePath(path: string): string;
+}
+//#endregion
+//#region src/architecture/core-api.d.ts
+declare class CoreApi {
+  get packageName(): string;
+  kindsOf(type: ClassType): CoreKind[];
+  markersOf(implemented: readonly NamedType[]): CoreMarker[];
+  isResult(shape: ReturnShape): boolean;
+  isDomainSymbol(name: string): boolean;
+  isPublishedLanguageSymbol(name: string): boolean;
+  private isKind;
+  private isMarker;
+  private isCore;
+}
+//#endregion
+//#region src/architecture/context-map.d.ts
+type Upstreams = Readonly<Record<string, readonly string[]>>;
+declare class ContextMap {
+  private readonly upstreams;
+  constructor(upstreams: Upstreams);
+  static ofEdges(edges: readonly {
+    readonly from: string;
+    readonly to: string;
+  }[]): ContextMap;
+  get contexts(): string[];
+  allows(from: string, to: string): boolean;
+  cycle(): string[] | undefined;
+  cycleThrough(from: string, to: string): boolean;
+  private cycleFrom;
+  private reaches;
+}
+//#endregion
+//#region src/architecture/settings.d.ts
+type SubdomainType = "core" | "supporting" | "generic";
+type Subdomains = Readonly<Partial<Record<SubdomainType, readonly string[]>>>;
+interface ContextFolder {
+  readonly name: string;
+  readonly dir: string;
+  readonly isSharedKernel: boolean;
+  readonly subdomain?: SubdomainType;
+}
+type ExtraFolders = Readonly<Partial<Record<"domain" | "application", readonly string[]>>>;
+interface Settings {
+  readonly rootDir: string;
+  readonly contextFolders: readonly ContextFolder[];
+  readonly compositionRoot: string;
+  readonly extraFolders: ExtraFolders;
+  readonly contextMap: ContextMap | undefined;
+  readonly domainDependencies: AllowedPackages;
+  readonly applicationDependencies: AllowedPackages;
+}
+//#endregion
+//#region src/architecture/paths/location.d.ts
 type Area = "context" | "shared-kernel" | "root" | "outside";
+type Unseen = "ignored" | "unresolved";
 interface LocationProps {
   readonly area: Area;
   readonly context?: string;
+  readonly subdomain?: SubdomainType;
   readonly layer?: Layer;
   readonly folder?: string;
+  readonly foldersInLayer?: readonly string[];
   readonly fileName: string;
   readonly isCompositionRoot?: boolean;
+  readonly unseen?: Unseen;
 }
 declare class Location {
   readonly area: Area;
   readonly context: string | undefined;
+  readonly subdomain: SubdomainType | undefined;
   readonly layer: Layer | undefined;
   readonly folder: string | undefined;
+  readonly foldersInLayer: readonly string[];
   readonly fileName: string;
   readonly isCompositionRoot: boolean;
+  readonly unseen: Unseen | undefined;
   constructor(props: LocationProps);
   get isInBoundedContext(): boolean;
+  get isInCoreDomain(): boolean;
   get isInSharedKernel(): boolean;
   get isAtRoot(): boolean;
   get isOutside(): boolean;
   get isInLayer(): boolean;
   isSameContextAs(other: Location): boolean;
   isOtherBoundedContextThan(other: Location): boolean;
-  describe(): string;
 }
 //#endregion
-//#region src/codebase/import.d.ts
-type ImportTarget = {
-  readonly kind: "file";
-  readonly path: string;
-  readonly location: Location;
-} | {
-  readonly kind: "package";
-  readonly name: string;
-};
-declare class Import {
-  readonly line: number;
-  readonly specifier: string;
-  readonly names: readonly string[];
-  readonly target: ImportTarget;
-  constructor(line: number, specifier: string, names: readonly string[], target: ImportTarget);
-  get label(): string;
-  isFromPackage(name: string): boolean;
+//#region src/architecture/paths/place.d.ts
+declare class Place {
+  readonly layer: Layer;
+  readonly folder: string | undefined;
+  readonly suffix: string | undefined;
+  constructor(spec: PlaceSpec);
+  fits(location: Location): boolean;
 }
 //#endregion
-//#region src/codebase/code-file.d.ts
-interface CodeFileProps {
-  readonly path: string;
-  readonly location: Location;
-  readonly imports: readonly Import[];
-  readonly classes: readonly CodeClass[];
-  readonly declarations: readonly Declaration[];
-  readonly domainErrorThrows: readonly number[];
+//#region src/architecture/building-blocks.d.ts
+interface MarkedPlace {
+  readonly marker: CoreMarker;
+  readonly place: Place;
 }
-declare class CodeFile {
-  readonly path: string;
-  readonly location: Location;
-  readonly imports: readonly Import[];
-  readonly classes: readonly CodeClass[];
-  readonly declarations: readonly Declaration[];
-  readonly domainErrorThrows: readonly number[];
-  constructor(props: CodeFileProps);
-  declaresOpenHostService(name: string): boolean;
-  get declaresAntiCorruptionLayer(): boolean;
+declare class BuildingBlocks {
+  private readonly core;
+  constructor(core: CoreApi);
+  placeOf(declaration: ClassDeclaration): Place | undefined;
+  markedPlacesOf(declaration: ClassDeclaration): MarkedPlace[];
+  foldersOf(layer: "domain" | "application"): readonly string[];
 }
 //#endregion
-//#region src/config/alveolus-config.d.ts
-type RuleId = "bc-isolation" | "domain-purity" | "layer-direction" | "driven-adapters-extend-port" | "reference-by-identity" | "command-query-separation" | "errors-as-values" | "placement" | "building-blocks-only";
-type RuleSetting = "error" | "off";
-interface AlveolusConfig {
-  readonly root: string;
-  readonly boundedContexts: Readonly<Record<string, string>>;
-  readonly sharedKernel?: string;
-  readonly compositionRoot?: string;
-  readonly domainDependencies?: readonly string[];
-  readonly ignore?: readonly string[];
-  readonly rules?: Readonly<Partial<Record<RuleId, RuleSetting>>>;
+//#region src/architecture/layers.d.ts
+declare class Layers {
+  isLayer(name: string): name is Layer;
+  importableFrom(layer: Exclude<Layer, "domain">): readonly Layer[];
 }
 //#endregion
-//#region src/config/config.d.ts
-interface ContextFolder {
-  readonly name: string;
-  readonly dir: string;
-  readonly isSharedKernel: boolean;
-}
-export declare class Config {
-  readonly projectDir: string;
-  readonly rootDir: string;
-  readonly compositionRoot: string;
-  readonly domainDependencies: readonly string[];
-  readonly contextFolders: readonly ContextFolder[];
-  private readonly ignored;
-  private readonly rules;
-  constructor(config: AlveolusConfig, projectDir: string);
-  isIgnored(path: string): boolean;
-  isEnabled(rule: RuleId): boolean;
-}
+//#region src/architecture/paths/layer-shape.d.ts
+type ShapeIssue = {
+  readonly kind: "directlyInLayer" | "tooDeep";
+  readonly layer: "domain" | "application";
+  readonly example: string;
+} | {
+  readonly kind: "unknownFolder";
+  readonly layer: "domain" | "application";
+  readonly folder: string;
+  readonly folders: readonly string[];
+} | {
+  readonly kind: "nestedPublishedLanguage" | "drivenWithoutTechnology" | "drivenTooDeep" | "drivingWithoutTechnology";
+};
 //#endregion
-//#region src/config/config-loader.d.ts
-export declare class ConfigLoader {
-  static readonly fileName = "alveolus.config.ts";
-  load(projectDir: string, configFile?: string): Promise<Config>;
-  private validate;
+//#region src/architecture/architecture.d.ts
+type FileTarget$1 = Extract<DependencyTarget, {
+  kind: "file";
+}>;
+export declare class Architecture {
+  readonly project: Project$1;
+  private readonly settings;
+  readonly core: CoreApi;
+  readonly layers: Layers;
+  readonly blocks: BuildingBlocks;
+  private readonly shape;
+  private readonly layout;
+  private readonly locations;
+  constructor(project: Project$1, settings: Settings);
+  get files(): readonly SourceFile[];
+  get domainDependencies(): AllowedPackages;
+  get applicationDependencies(): AllowedPackages;
+  get contextMap(): ContextMap | undefined;
+  locationOf(file: SourceFile): Location;
+  locationOfTarget(target: FileTarget$1): Location;
+  shapeIssueOf(location: Location): ShapeIssue | undefined;
+  relativePath(path: string): string;
+  kindsOf(subject: ClassType | ClassDeclaration): CoreKind[];
+  kindOf(subject: ClassType | ClassDeclaration): CoreKind | undefined;
+  is(subject: ClassType | ClassDeclaration, kind: CoreKind): boolean;
+  isBuildingBlock(subject: ClassType | ClassDeclaration): boolean;
+  implementsMarker(declaration: ClassDeclaration, marker: CoreMarker): boolean;
+  returnsResult(member: Member): boolean;
+  classOf(type: ClassType): ClassDeclaration | undefined;
+  private locate;
+  private typeOf;
 }
 //#endregion
-//#region src/config/define-config.d.ts
-export declare function defineConfig(config: AlveolusConfig): AlveolusConfig;
+//#region src/rules/framework/finding.d.ts
+type FindingData = Readonly<Record<string, string | number>>;
+interface Finding<MessageId extends string = string> {
+  readonly file: SourceFile;
+  readonly line: number;
+  readonly symbol: string;
+  readonly messageId: MessageId;
+  readonly data: FindingData;
+}
 //#endregion
-//#region src/codebase/codebase.d.ts
-declare class Codebase {
-  readonly files: readonly CodeFile[];
-  readonly config: Config;
-  private readonly filesByPath;
-  constructor(files: readonly CodeFile[], config: Config);
-  file(path: string): CodeFile | undefined;
-  relativePath(path: string): string;
+//#region src/rules/framework/wording.d.ts
+type FileTarget = Extract<DependencyTarget, {
+  kind: "file";
+}>;
+declare class Wording {
+  target(target: FileTarget, architecture: Architecture): string;
+  location(location: Location): string;
+  place(place: Place): string;
 }
 //#endregion
-//#region src/analysis/code-analyzer.d.ts
-export declare abstract class CodeAnalyzer {
-  abstract analyze(config: Config): Codebase;
+//#region src/rules/framework/rule.d.ts
+type RuleContexts = "every" | "core";
+interface RuleMeta<Id extends string, MessageId extends string> {
+  readonly id: Id;
+  readonly contexts: RuleContexts;
+  readonly description: string;
+  readonly messages: Readonly<Record<MessageId, string>>;
+}
+export declare abstract class Rule<Id extends string = string, MessageId extends string = string> {
+  abstract readonly meta: RuleMeta<Id, MessageId>;
+  protected readonly wording: Wording;
+  abstract check(architecture: Architecture): Finding<MessageId>[];
+  protected filesOf(architecture: Architecture): SourceFile[];
+  private checks;
+  protected finding(file: SourceFile, line: number, symbol: string, messageId: MessageId, data?: FindingData): Finding<MessageId>;
 }
 //#endregion
-//#region src/analysis/ts-morph-analyzer.d.ts
-export declare class TsMorphAnalyzer extends CodeAnalyzer {
-  private readonly project;
-  private readonly types;
-  private readonly classes;
-  constructor(project: Project);
-  static fromTsConfig(projectDir: string): TsMorphAnalyzer;
-  analyze(config: Config): Codebase;
-  private read;
-  private declarationsOf;
-  private moduleDeclarationsOf;
-  private readImport;
-  private importedNames;
-  private targetOf;
-  private packageNameOf;
-  private domainErrorThrowsOf;
-  private isInside;
+//#region src/rules/tooling/no-loose-disable.rule.d.ts
+type MessageId = "noRule" | "unknownRule" | "noReason" | "unused";
+declare class NoLooseDisableRule extends Rule<"tooling/no-loose-disable", MessageId> {
+  private readonly knownRules;
+  readonly meta: RuleMeta<"tooling/no-loose-disable", MessageId>;
+  constructor(knownRules: readonly string[]);
+  check(architecture: Architecture): Finding<MessageId>[];
+  unused(file: SourceFile, comment: DisableComment): Finding<MessageId>;
+  private malformed;
 }
 //#endregion
-//#region src/rules/problem.d.ts
-interface Problem {
-  readonly line: number;
-  readonly symbol: string;
-  readonly message: string;
+//#region src/rules/registry.d.ts
+declare const ruleIds: readonly ["strategic/no-cross-context-import", "strategic/no-leaky-host-service", "strategic/no-unmapped-context", "strategic/no-fat-shared-kernel", "layers/no-impure-domain", "layers/no-outward-import", "layers/no-portless-adapter", "layers/no-driving-shortcut", "tactical/no-aggregate-reference", "tactical/no-public-field", "tactical/no-foreign-command-dependency", "tactical/no-foreign-query-dependency", "tactical/no-stateful-service", "tactical/no-thrown-failure", "tactical/no-misplaced-class", "tactical/no-loose-code", "tooling/no-loose-disable"];
+type RuleId = (typeof ruleIds)[number];
+export declare class RuleRegistry {
+  readonly rules: readonly Rule<RuleId>[];
+  get looseDisable(): NoLooseDisableRule;
+  get ids(): RuleId[];
 }
 //#endregion
-//#region src/rules/violation.d.ts
+//#region src/check/violation.d.ts
+type Severity = "error" | "warn" | "info";
 interface Violation {
   readonly rule: RuleId;
+  readonly severity: Severity;
   readonly file: string;
   readonly line: number;
   readonly symbol: string;
   readonly message: string;
+  readonly fingerprint: string;
 }
 //#endregion
-//#region src/rules/rule.d.ts
-export declare abstract class Rule {
-  abstract readonly id: RuleId;
-  abstract check(codebase: Codebase): Violation[];
-  protected violation(codebase: Codebase, file: CodeFile, problem: Problem): Violation;
-}
-//#endregion
-//#region src/rules/rules.d.ts
-export declare class Rules {
-  static all(): Rule[];
-}
-//#endregion
-//#region src/baseline/baseline.d.ts
+//#region src/check/baseline.d.ts
 export declare class Baseline {
   private readonly entries;
   static readonly fileName = "alveolus.baseline.json";
   private constructor();
   static of(violations: readonly Violation[]): Baseline;
   static load(path: string): Promise<Baseline>;
+  get size(): number;
+  get outdatedEntries(): number;
   newViolations(violations: readonly Violation[]): Violation[];
+  staleEntries(violations: readonly Violation[]): number;
+  private match;
   save(path: string): Promise<void>;
   private keyOf;
 }
 //#endregion
-//#region src/checker/arch-checker.d.ts
-export declare class ArchChecker {
-  private readonly analyzer;
+//#region src/importer/importer.d.ts
+interface ImportScope {
+  readonly projectDir: string;
+  readonly rootDir: string;
+  isIgnored(path: string): boolean;
+}
+export declare abstract class Importer {
+  abstract read(scope: ImportScope): Project$1;
+  abstract resolves(packageName: string, scope: ImportScope): boolean;
+}
+//#endregion
+//#region src/importer/ts-morph/ts-morph-importer.d.ts
+export declare class TsMorphImporter extends Importer {
+  private readonly sources;
+  private readonly classes;
+  private readonly statements;
+  private readonly disables;
+  private readonly throws;
+  constructor(sources: Project);
+  static fromTsConfig(tsConfigFilePath: string): TsMorphImporter;
+  resolves(packageName: string, scope: ImportScope): boolean;
+  read(scope: ImportScope): Project$1;
+  private readFile;
+  private globalUsesOf;
+  private isInside;
+}
+//#endregion
+//#region src/check/checker.d.ts
+interface CheckSettings extends ImportScope, Settings {
+  severityOf(rule: RuleId): Severity | "off";
+}
+interface Suppressed {
+  readonly violation: Violation;
+  readonly reason: string;
+}
+interface CheckOutcome {
+  readonly files: number;
+  readonly violations: Violation[];
+  readonly suppressed: Suppressed[];
+}
+export declare class Checker {
+  private readonly importer;
   private readonly rules;
-  constructor(analyzer: CodeAnalyzer, rules: readonly Rule[]);
-  check(config: Config): Violation[];
+  private readonly fingerprint;
+  constructor(importer: Importer, rules: readonly Rule<RuleId>[]);
+  check(settings: CheckSettings): CheckOutcome;
+  run(rule: Rule<RuleId>, architecture: Architecture): Violation[];
+  private collect;
+  private collectUnusedDisables;
+  private violationOf;
+  private messageOf;
+  private fill;
   private compare;
 }
 //#endregion
+//#region src/check/report.d.ts
+interface ReportInput {
+  readonly files: number;
+  readonly violations: readonly Violation[];
+  readonly suppressed: readonly Suppressed[];
+  readonly baselined: number;
+  readonly stale: number;
+}
+export declare class Report {
+  private readonly input;
+  private readonly colors;
+  constructor(input: ReportInput, colored?: boolean);
+  text(): string;
+  json(): string;
+  sarif(rules: readonly RuleMeta<string, string>[]): string;
+  private byFile;
+  private block;
+  private severity;
+  private summary;
+  private counts;
+}
+//#endregion
 //#region src/cli/cli.d.ts
 interface Output {
   write(text: string): unknown;
@@ -266,22 +550,62 @@ export declare class Cli {
   private program;
   private withOptions;
   private check;
+  private render;
+  private warnOutdated;
   private baseline;
   private analyze;
   private fail;
 }
 //#endregion
-//#region src/report/report.d.ts
-export declare class Report {
-  private readonly violations;
-  private readonly baselined;
-  private readonly colors;
-  constructor(violations: readonly Violation[], baselined: number, colored?: boolean);
-  text(): string;
-  json(): string;
-  private block;
-  private summary;
+//#region src/config/alveolus-config.d.ts
+type RuleSetting = "error" | "warn" | "info" | "off";
+interface LayoutConfig {
+  readonly extraFolders?: Readonly<Partial<Record<"domain" | "application", readonly string[]>>>;
+}
+interface AlveolusConfig {
+  readonly root: string;
+  readonly tsconfig?: string;
+  readonly boundedContexts: Readonly<Record<string, string>>;
+  readonly sharedKernel?: string;
+  readonly subdomains?: Subdomains;
+  readonly contextMap?: Upstreams;
+  readonly compositionRoot?: string;
+  readonly domainDependencies?: PackageDependencies;
+  readonly applicationDependencies?: PackageDependencies;
+  readonly ignore?: readonly string[];
+  readonly layout?: LayoutConfig;
+  readonly rules?: Readonly<Partial<Record<RuleId, RuleSetting>>>;
 }
 //#endregion
-export type { AlveolusConfig, RuleId, RuleSetting, Violation };
+//#region src/config/config.d.ts
+export declare class Config implements CheckSettings {
+  readonly projectDir: string;
+  readonly rootDir: string;
+  readonly tsConfigPath: string;
+  readonly compositionRoot: string;
+  readonly domainDependencies: AllowedPackages;
+  readonly applicationDependencies: AllowedPackages;
+  readonly contextFolders: readonly ContextFolder[];
+  readonly extraFolders: ExtraFolders;
+  readonly contextMap: ContextMap | undefined;
+  private readonly ignored;
+  private readonly rules;
+  constructor(config: AlveolusConfig, projectDir: string);
+  private classifiedContexts;
+  private validContextMap;
+  isIgnored(path: string): boolean;
+  severityOf(rule: RuleId): Severity | "off";
+}
+//#endregion
+//#region src/config/config-loader.d.ts
+export declare class ConfigLoader {
+  static readonly fileName = "alveolus.config.ts";
+  load(projectDir: string, configFile?: string): Promise<Config>;
+  private validate;
+}
+//#endregion
+//#region src/config/define-config.d.ts
+export declare function defineConfig(config: AlveolusConfig): AlveolusConfig;
+//#endregion
+export type { AlveolusConfig, CheckSettings, Finding, FindingData, ImportScope, PackageDependencies, RuleId, RuleMeta, RuleSetting, Settings, Violation };
 //# sourceMappingURL=index.d.mts.map