@aoelite/refpact-ts 0.0.0-stage → 0.1.2

package/dist/group.d.ts

@@ -0,0 +1,74 @@
+/** Groups: several rules that are checked together and report every failure. */
+import type { Baseline } from "./baseline.ts";
+import type { Project } from "./frontend/project.ts";
+import type { Failure, ImportRule } from "./rules.ts";
+/**
+ * Rules that are checked together, so that one check reports every rule that fails, not only
+ * the first. {@link rules}, {@link layers} and {@link onionArchitecture} give sets of rules,
+ * and a class of your own can be one: say which rules it stands for, and it is checked as
+ * they are.
+ *
+ * ```ts
+ * class NoDatabase extends RuleSet {
+ *   readonly name = "no part imports the database";
+ *   private readonly parts: readonly string[];
+ *
+ *   constructor(parts: readonly string[]) {
+ *     super();
+ *     this.parts = parts;
+ *   }
+ *
+ *   rules(): ImportRule[] {
+ *     return this.parts.map((part) =>
+ *       rule(`${part} does not import the database`).files(anyOf(`src/${part}/**`)).mustNotImport(anyOf("src/db/**")),
+ *     );
+ *   }
+ * }
+ *
+ * new NoDatabase(["ui", "domain"]).check(app);
+ * ```
+ */
+export declare abstract class RuleSet {
+    /** The name of the set. It names the failure of a set without rules. */
+    abstract readonly name: string;
+    /**
+     * The rules of the set. Throw an {@link ArchitectureError} of type `malformed` when the
+     * set cannot fail as written.
+     */
+    abstract rules(): ImportRule[];
+    /**
+     * Checks all rules and returns the failure, or `undefined` when all pass. The failure is
+     * that of one rule, or `several` in the order of the rules. A set without rules cannot
+     * fail, so it is `malformed`.
+     */
+    verify(project: Project): Failure | undefined;
+    /** Throws an {@link ArchitectureError} when a rule is violated or cannot be evaluated. The report has every rule that fails. */
+    check(project: Project): void;
+    /** Like {@link RuleSet.verify}, with a baseline. See {@link ImportRule.verifyWithBaseline}. */
+    verifyWithBaseline(project: Project, baseline: Baseline): Failure | undefined;
+    /** Like {@link RuleSet.check}, with a baseline. See {@link ImportRule.checkWithBaseline}. */
+    checkWithBaseline(project: Project, baseline: Baseline): void;
+    private all;
+}
+/**
+ * Rules that are checked together: one check reports every rule that fails, not only the
+ * first.
+ *
+ * ```ts
+ * rules(
+ *   "the platform rules",
+ *   rule("files are read in the platform only").files(allExcept("src/platform/**")).mustNotImport(anyOf(pkg("node:fs"))),
+ *   rule("the platform forms no cycle").files(anyOf("src/platform/**")).mustBeAcyclic(),
+ * ).check(app);
+ * ```
+ */
+export declare class Rules extends RuleSet {
+    readonly name: string;
+    private readonly list;
+    /** @internal */
+    constructor(name: string, list: readonly ImportRule[]);
+    /** The rules of the group. */
+    rules(): ImportRule[];
+}
+/** Groups rules, so that one check reports every rule that fails. */
+export declare function rules(name: string, ...list: ImportRule[]): Rules;

package/dist/group.js

@@ -0,0 +1,106 @@
+import { ArchitectureError } from "./rules.js";
+/**
+ * Rules that are checked together, so that one check reports every rule that fails, not only
+ * the first. {@link rules}, {@link layers} and {@link onionArchitecture} give sets of rules,
+ * and a class of your own can be one: say which rules it stands for, and it is checked as
+ * they are.
+ *
+ * ```ts
+ * class NoDatabase extends RuleSet {
+ *   readonly name = "no part imports the database";
+ *   private readonly parts: readonly string[];
+ *
+ *   constructor(parts: readonly string[]) {
+ *     super();
+ *     this.parts = parts;
+ *   }
+ *
+ *   rules(): ImportRule[] {
+ *     return this.parts.map((part) =>
+ *       rule(`${part} does not import the database`).files(anyOf(`src/${part}/**`)).mustNotImport(anyOf("src/db/**")),
+ *     );
+ *   }
+ * }
+ *
+ * new NoDatabase(["ui", "domain"]).check(app);
+ * ```
+ */
+export class RuleSet {
+    /**
+     * Checks all rules and returns the failure, or `undefined` when all pass. The failure is
+     * that of one rule, or `several` in the order of the rules. A set without rules cannot
+     * fail, so it is `malformed`.
+     */
+    verify(project) {
+        return this.all((made) => made.verify(project));
+    }
+    /** Throws an {@link ArchitectureError} when a rule is violated or cannot be evaluated. The report has every rule that fails. */
+    check(project) {
+        const failure = this.verify(project);
+        if (failure !== undefined) {
+            throw new ArchitectureError(failure);
+        }
+    }
+    /** Like {@link RuleSet.verify}, with a baseline. See {@link ImportRule.verifyWithBaseline}. */
+    verifyWithBaseline(project, baseline) {
+        return this.all((made) => made.verifyWithBaseline(project, baseline));
+    }
+    /** Like {@link RuleSet.check}, with a baseline. See {@link ImportRule.checkWithBaseline}. */
+    checkWithBaseline(project, baseline) {
+        const failure = this.verifyWithBaseline(project, baseline);
+        if (failure !== undefined) {
+            throw new ArchitectureError(failure);
+        }
+    }
+    all(verify) {
+        let list;
+        try {
+            list = this.rules();
+        }
+        catch (error) {
+            if (error instanceof ArchitectureError) {
+                return error.failure;
+            }
+            throw error;
+        }
+        if (list.length === 0) {
+            const message = `rule \`${this.name}\` cannot be checked:\n  the group has no rules, so it cannot fail`;
+            return { type: "malformed", rule: this.name, message };
+        }
+        const failures = list.flatMap((made) => verify(made) ?? []);
+        if (failures.length <= 1) {
+            return failures[0];
+        }
+        return { type: "several", failures, message: failures.map((failure) => failure.message).join("\n") };
+    }
+}
+/**
+ * Rules that are checked together: one check reports every rule that fails, not only the
+ * first.
+ *
+ * ```ts
+ * rules(
+ *   "the platform rules",
+ *   rule("files are read in the platform only").files(allExcept("src/platform/**")).mustNotImport(anyOf(pkg("node:fs"))),
+ *   rule("the platform forms no cycle").files(anyOf("src/platform/**")).mustBeAcyclic(),
+ * ).check(app);
+ * ```
+ */
+export class Rules extends RuleSet {
+    name;
+    list;
+    /** @internal */
+    constructor(name, list) {
+        super();
+        this.name = name;
+        this.list = list;
+    }
+    /** The rules of the group. */
+    rules() {
+        return [...this.list];
+    }
+}
+/** Groups rules, so that one check reports every rule that fails. */
+export function rules(name, ...list) {
+    return new Rules(name, list);
+}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Architecture tests for TypeScript 6 and 7 projects: rules about what files may import, checked
+ * as ordinary tests.
+ *
+ * ```ts
+ * import { allExcept, anyOf, loadProject, pkg, rule } from "@aoelite/refpact-ts";
+ *
+ * const app = loadProject("tsconfig.json");
+ *
+ * rule("the user interface does not import the database")
+ *   .files(anyOf("src/ui/**"))
+ *   .mustNotImport(anyOf("src/db/**", pkg("pg")))
+ *   .check(app);
+ * ```
+ */
+export { Baseline, baseline } from "./baseline.ts";
+export { Graph, ItemScope, Scope } from "./custom.ts";
+export type { ImportEdge, SeenImport, SeenMarker } from "./custom.ts";
+export { compilerVersion } from "./frontend/compiler.ts";
+export type { Filters } from "./filters.ts";
+export { Rules, RuleSet, rules } from "./group.ts";
+export { ItemSelection } from "./items.ts";
+export type { ItemKind, Modifier, Visibility } from "./items.ts";
+export { Layers, layers } from "./layers.ts";
+export { loadProject, Project } from "./frontend/project.ts";
+export { Onion, onionArchitecture } from "./onion.ts";
+export type { LoadOptions } from "./frontend/project.ts";
+export type { ComponentExtension } from "./frontend/components.ts";
+export { DEPENDENCY_KINDS } from "./frontend/dependencies.ts";
+export type { DependencyKind } from "./frontend/dependencies.ts";
+export { all, allExcept, AnyOf, anyOf, ArchitectureError, Files, globalApi, ImportRule, KINDS, MARKERS, NamedRule, PackageTarget, pkg, rule, ScopedRule, Targets, unverified, } from "./rules.ts";
+export type { CheckPatterns, Failure, Kind, Marker, Target } from "./rules.ts";
+export type { Detail, DiagramFormat, DiagramLayer, DiagramNodes, End, ErrorCode, FactSet, Role, RuleError, StaleEntry, Step, Violation } from "./core/index.ts";
+/** The language-neutral core: the rule model and its evaluation. */
+export * as core from "./core/index.ts";

package/dist/index.js

@@ -0,0 +1,27 @@
+/**
+ * Architecture tests for TypeScript 6 and 7 projects: rules about what files may import, checked
+ * as ordinary tests.
+ *
+ * ```ts
+ * import { allExcept, anyOf, loadProject, pkg, rule } from "@aoelite/refpact-ts";
+ *
+ * const app = loadProject("tsconfig.json");
+ *
+ * rule("the user interface does not import the database")
+ *   .files(anyOf("src/ui/**"))
+ *   .mustNotImport(anyOf("src/db/**", pkg("pg")))
+ *   .check(app);
+ * ```
+ */
+export { Baseline, baseline } from "./baseline.js";
+export { Graph, ItemScope, Scope } from "./custom.js";
+export { compilerVersion } from "./frontend/compiler.js";
+export { Rules, RuleSet, rules } from "./group.js";
+export { ItemSelection } from "./items.js";
+export { Layers, layers } from "./layers.js";
+export { loadProject, Project } from "./frontend/project.js";
+export { Onion, onionArchitecture } from "./onion.js";
+export { DEPENDENCY_KINDS } from "./frontend/dependencies.js";
+export { all, allExcept, AnyOf, anyOf, ArchitectureError, Files, globalApi, ImportRule, KINDS, MARKERS, NamedRule, PackageTarget, pkg, rule, ScopedRule, Targets, unverified, } from "./rules.js";
+/** The language-neutral core: the rule model and its evaluation. */
+export * as core from "./core/index.js";

package/dist/items.d.ts

@@ -0,0 +1,133 @@
+/** Rules about items: where they are, what they are named, what they extend or implement, and the types in their signatures. */
+import type { CustomConstraint, RawPattern, Related, Rule as CoreRule, Violation } from "./core/index.ts";
+import type { ItemScope, ListNames } from "./custom.ts";
+import type { ItemKind, Modifier, Visibility } from "./frontend/declarations.ts";
+import type { AnyOf, CheckPatterns, Files, Finder, ImportRule, Target } from "./rules.ts";
+export type { ItemKind, Modifier, Visibility };
+/** What an item selection needs from the rules, which import it. @internal */
+export interface Maker {
+    readonly rule: (rule: CoreRule, finder?: Finder) => ImportRule;
+    readonly custom: (patterns: CheckPatterns | undefined) => {
+        constraint: CustomConstraint;
+        names: ListNames;
+    };
+    readonly subjects: (files: Files) => CoreRule["subjects"];
+    readonly file: (pattern: string) => RawPattern;
+    readonly target: (target: Target) => RawPattern;
+}
+interface Filters {
+    readonly named?: readonly string[];
+    readonly kinds?: readonly string[];
+    readonly visibilities?: readonly string[];
+    readonly modifiers?: readonly string[];
+    readonly related: readonly Related[];
+}
+/**
+ * Items of some files, narrowed by filters. Each filter narrows the selection; the values
+ * that one filter takes form a union. End with a `must..` method.
+ *
+ * ```ts
+ * rule("services live in the services folder")
+ *   .items(all())
+ *   .named("*Service")
+ *   .ofKind("class")
+ *   .mustResideIn(anyOf("src/services/**"))
+ *   .check(app);
+ * ```
+ */
+export declare class ItemSelection {
+    private readonly name;
+    private readonly files;
+    private readonly filters;
+    private readonly maker;
+    /** @internal */
+    constructor(name: string, files: Files, maker: Maker, filters?: Filters);
+    /** Only items whose name one of the globs matches. `*` matches any run of characters: `*Service`. */
+    named(...globs: string[]): ItemSelection;
+    /** Only items of these kinds. */
+    ofKind(...kinds: ItemKind[]): ItemSelection;
+    /** Only items with one of these visibilities. */
+    withVisibility(...visibilities: Visibility[]): ItemSelection;
+    /**
+     * Only items with one of these modifiers: `withModifier("async")` selects the `async`
+     * functions, and the variables that hold an `async` arrow function or function expression.
+     */
+    withModifier(...modifiers: Modifier[]): ItemSelection;
+    /** Only classes and interfaces that extend one of the targets. A target that nothing extends is an error. */
+    extending(targets: AnyOf): ItemSelection;
+    /** Only classes that implement one of the targets. */
+    implementing(targets: AnyOf): ItemSelection;
+    /** Only classes with a decorator that is one of the targets. */
+    decoratedWith(targets: AnyOf): ItemSelection;
+    /**
+     * Only classes and interfaces that extend or implement one of the targets, directly or
+     * through other types of the project: when `Order extends Entity` and `Entity implements
+     * Saved`, `Order` is assignable to `Saved`. An item is not assignable to itself.
+     */
+    assignableTo(targets: AnyOf): ItemSelection;
+    /**
+     * Only functions with one of the targets in their return type: `(): Promise<Order>` returns
+     * the type `Order`. A variable that holds an arrow function or a function expression
+     * counts as a function. Only the written type counts, not an inferred one.
+     */
+    returning(targets: AnyOf): ItemSelection;
+    /** Only functions with one of the targets in the type of a parameter. `this` does not count. */
+    taking(targets: AnyOf): ItemSelection;
+    /** Only variables with one of the targets in their written type: `const pool: Pool = ..`. */
+    ofType(targets: AnyOf): ItemSelection;
+    /** No item may be selected: "no exported item in `src/internal`". */
+    mustNotExist(): ImportRule;
+    /** Each item must be declared in one of these files. */
+    mustResideIn(files: AnyOf<string>): ImportRule;
+    /** The name of each item must match one of the globs. */
+    mustBeNamed(...globs: string[]): ImportRule;
+    /** Each item must extend one of the targets. */
+    mustExtend(targets: AnyOf): ImportRule;
+    /**
+     * Each item must have at most this number of lines, from the line of its name to the line
+     * on which its declaration ends. The decorators and the comments above the name do not
+     * count.
+     *
+     * ```ts
+     * rule("no function is longer than 60 lines").items(anyOf("src/**")).ofKind("function").mustNotExceedLines(60).check(app);
+     * ```
+     */
+    mustNotExceedLines(lines: number): ImportRule;
+    /** Each item must implement one of the targets. */
+    mustImplement(targets: AnyOf): ImportRule;
+    /** Each item must extend or implement one of the targets, directly or through other types. */
+    mustBeAssignableTo(targets: AnyOf): ImportRule;
+    /**
+     * Each item must have one of these modifiers.
+     *
+     * ```ts
+     * rule("the exports are documented").items(anyOf("src/**")).withVisibility("exported").mustHaveModifier("documented").check(app);
+     * ```
+     */
+    mustHaveModifier(...modifiers: Modifier[]): ImportRule;
+    /** Each item must have a decorator that is one of the targets. */
+    mustBeDecoratedWith(targets: AnyOf): ImportRule;
+    /**
+     * The items must pass a check of your own: a function that gets the {@link ItemScope} of
+     * the rule and returns the violations. The scope has the items that the filters above
+     * select, and all that the scope of a rule about files has. The check names the lists of
+     * patterns that it needs: see {@link CheckPatterns}.
+     *
+     * ```ts
+     * rule("a subclass is exported")
+     *   .items(anyOf("src/**"))
+     *   .ofKind("class")
+     *   .mustSatisfy((scope) =>
+     *     scope.items
+     *       .filter((item) => item.visibility === "local" && item.relations.some((tie) => tie.relation === "extends"))
+     *       .map((item) => scope.violationOfItem(item, `declares ${item.name}, which extends a class and is not exported`)),
+     *   )
+     *   .check(app);
+     * ```
+     */
+    mustSatisfy(check: (scope: ItemScope) => readonly Violation[], patterns?: CheckPatterns): ImportRule;
+    private related;
+    private relate;
+    private with;
+    private rule;
+}

package/dist/items.js

@@ -0,0 +1,179 @@
+/**
+ * Items of some files, narrowed by filters. Each filter narrows the selection; the values
+ * that one filter takes form a union. End with a `must..` method.
+ *
+ * ```ts
+ * rule("services live in the services folder")
+ *   .items(all())
+ *   .named("*Service")
+ *   .ofKind("class")
+ *   .mustResideIn(anyOf("src/services/**"))
+ *   .check(app);
+ * ```
+ */
+export class ItemSelection {
+    name;
+    files;
+    filters;
+    maker;
+    /** @internal */
+    constructor(name, files, maker, filters = { related: [] }) {
+        this.name = name;
+        this.files = files;
+        this.maker = maker;
+        this.filters = filters;
+    }
+    /** Only items whose name one of the globs matches. `*` matches any run of characters: `*Service`. */
+    named(...globs) {
+        return this.with({ named: [...(this.filters.named ?? []), ...globs] });
+    }
+    /** Only items of these kinds. */
+    ofKind(...kinds) {
+        return this.with({ kinds: [...(this.filters.kinds ?? []), ...kinds] });
+    }
+    /** Only items with one of these visibilities. */
+    withVisibility(...visibilities) {
+        return this.with({ visibilities: [...(this.filters.visibilities ?? []), ...visibilities] });
+    }
+    /**
+     * Only items with one of these modifiers: `withModifier("async")` selects the `async`
+     * functions, and the variables that hold an `async` arrow function or function expression.
+     */
+    withModifier(...modifiers) {
+        return this.with({ modifiers: [...(this.filters.modifiers ?? []), ...modifiers] });
+    }
+    /** Only classes and interfaces that extend one of the targets. A target that nothing extends is an error. */
+    extending(targets) {
+        return this.related("extends", targets);
+    }
+    /** Only classes that implement one of the targets. */
+    implementing(targets) {
+        return this.related("implements", targets);
+    }
+    /** Only classes with a decorator that is one of the targets. */
+    decoratedWith(targets) {
+        return this.related("decorator", targets);
+    }
+    /**
+     * Only classes and interfaces that extend or implement one of the targets, directly or
+     * through other types of the project: when `Order extends Entity` and `Entity implements
+     * Saved`, `Order` is assignable to `Saved`. An item is not assignable to itself.
+     */
+    assignableTo(targets) {
+        return this.related("assignable-to", targets);
+    }
+    /**
+     * Only functions with one of the targets in their return type: `(): Promise<Order>` returns
+     * the type `Order`. A variable that holds an arrow function or a function expression
+     * counts as a function. Only the written type counts, not an inferred one.
+     */
+    returning(targets) {
+        return this.related("returns", targets);
+    }
+    /** Only functions with one of the targets in the type of a parameter. `this` does not count. */
+    taking(targets) {
+        return this.related("takes", targets);
+    }
+    /** Only variables with one of the targets in their written type: `const pool: Pool = ..`. */
+    ofType(targets) {
+        return this.related("has-type", targets);
+    }
+    /** No item may be selected: "no exported item in `src/internal`". */
+    mustNotExist() {
+        return this.rule({ type: "not-exist" });
+    }
+    /** Each item must be declared in one of these files. */
+    mustResideIn(files) {
+        return this.rule({ type: "reside-in", places: files.patterns.map(this.maker.file) });
+    }
+    /** The name of each item must match one of the globs. */
+    mustBeNamed(...globs) {
+        return this.rule({ type: "be-named", names: globs });
+    }
+    /** Each item must extend one of the targets. */
+    mustExtend(targets) {
+        return this.rule({ type: "have", ...this.relate("extends", targets) });
+    }
+    /**
+     * Each item must have at most this number of lines, from the line of its name to the line
+     * on which its declaration ends. The decorators and the comments above the name do not
+     * count.
+     *
+     * ```ts
+     * rule("no function is longer than 60 lines").items(anyOf("src/**")).ofKind("function").mustNotExceedLines(60).check(app);
+     * ```
+     */
+    mustNotExceedLines(lines) {
+        return this.rule({ type: "not-exceed-lines", lines });
+    }
+    /** Each item must implement one of the targets. */
+    mustImplement(targets) {
+        return this.rule({ type: "have", ...this.relate("implements", targets) });
+    }
+    /** Each item must extend or implement one of the targets, directly or through other types. */
+    mustBeAssignableTo(targets) {
+        return this.rule({ type: "have", ...this.relate("assignable-to", targets) });
+    }
+    /**
+     * Each item must have one of these modifiers.
+     *
+     * ```ts
+     * rule("the exports are documented").items(anyOf("src/**")).withVisibility("exported").mustHaveModifier("documented").check(app);
+     * ```
+     */
+    mustHaveModifier(...modifiers) {
+        return this.rule({ type: "have-modifier", modifiers });
+    }
+    /** Each item must have a decorator that is one of the targets. */
+    mustBeDecoratedWith(targets) {
+        return this.rule({ type: "have", ...this.relate("decorator", targets) });
+    }
+    /**
+     * The items must pass a check of your own: a function that gets the {@link ItemScope} of
+     * the rule and returns the violations. The scope has the items that the filters above
+     * select, and all that the scope of a rule about files has. The check names the lists of
+     * patterns that it needs: see {@link CheckPatterns}.
+     *
+     * ```ts
+     * rule("a subclass is exported")
+     *   .items(anyOf("src/**"))
+     *   .ofKind("class")
+     *   .mustSatisfy((scope) =>
+     *     scope.items
+     *       .filter((item) => item.visibility === "local" && item.relations.some((tie) => tie.relation === "extends"))
+     *       .map((item) => scope.violationOfItem(item, `declares ${item.name}, which extends a class and is not exported`)),
+     *   )
+     *   .check(app);
+     * ```
+     */
+    mustSatisfy(check, patterns) {
+        const { constraint, names } = this.maker.custom(patterns);
+        return this.rule(constraint, { names, find: (scope) => check(scope) });
+    }
+    related(relation, targets) {
+        return this.with({ related: [...this.filters.related, this.relate(relation, targets)] });
+    }
+    relate(relation, targets) {
+        return { relation, anyOf: targets.patterns.map(this.maker.target) };
+    }
+    with(change) {
+        return new ItemSelection(this.name, this.files, this.maker, { ...this.filters, ...change });
+    }
+    rule(must, finder) {
+        const { named, kinds, visibilities, modifiers, related } = this.filters;
+        const rule = {
+            name: this.name,
+            subjects: this.maker.subjects(this.files),
+            constraint: {
+                type: "items",
+                ...(named !== undefined && { named }),
+                ...(kinds !== undefined && { kinds }),
+                ...(visibilities !== undefined && { visibilities }),
+                ...(modifiers !== undefined && { modifiers }),
+                related,
+                must,
+            },
+        };
+        return this.maker.rule(rule, finder);
+    }
+}

package/dist/layers.d.ts

@@ -0,0 +1,112 @@
+import type { Filter, Filters } from "./filters.ts";
+import { RuleSet } from "./group.ts";
+import type { DiagramFormat } from "./core/index.ts";
+import type { Project } from "./frontend/project.ts";
+import { AnyOf, Files } from "./rules.ts";
+import type { ImportRule } from "./rules.ts";
+interface Settings {
+    readonly name: string;
+    readonly list: readonly {
+        readonly name: string;
+        readonly files: readonly string[];
+    }[];
+    /** The filters of every rule of the layers. */
+    readonly filters: readonly Filter[];
+    readonly strict: boolean;
+    /** For a layer, the only layers it may import. */
+    readonly mayOnlyImport: readonly (readonly [string, readonly string[]])[];
+    /** For a layer, the only layers that may import it. */
+    readonly mayOnlyBeImportedBy: readonly (readonly [string, readonly string[]])[];
+    /** The files that must each be in a layer. */
+    readonly covered: AnyOf<string> | Files | undefined;
+}
+/**
+ * Layers from the top to the bottom. A layer may import the layers below it. It must not
+ * import a layer above it.
+ *
+ * ```ts
+ * layers("the layers of the shop")
+ *   .layer("ui", "src/ui/**")
+ *   .layer("domain", "src/domain/**")
+ *   .layer("db", "src/db/**")
+ *   .mayOnlyBeImportedBy("db", "domain")
+ *   .everyFileInALayer(allExcept("src/main.ts"))
+ *   .check(app);
+ * ```
+ *
+ * The layers have the filters of a rule ({@link Filters}), such as `ignoringTypeImports()`,
+ * `ignoringImport(..)` and `asWarning()`. A filter applies to every rule of the layers and to
+ * their diagram.
+ */
+export interface Layers extends Filters<Layers> {
+}
+export declare class Layers extends RuleSet {
+    private readonly settings;
+    /** @internal */
+    constructor(settings: Settings);
+    /** The name of the layers. */
+    get name(): string;
+    /** Adds a layer below the layers that are there. */
+    layer(name: string, ...files: string[]): Layers;
+    /** @internal The layers with one more filter. */
+    filtered(filter: Filter): Layers;
+    /** Makes the layers strict: a layer may import only the layer right below it, not the layers further down. */
+    strict(): Layers;
+    /**
+     * The layer may import only these layers. Each of them must be below it, and right below
+     * it when the layers are {@link Layers.strict | strict}. No layers forbids the layer to
+     * import any other layer.
+     */
+    mayOnlyImport(layer: string, ...layers: string[]): Layers;
+    /**
+     * Only these layers may import the layer. Each of them must be above it, and right above
+     * it when the layers are {@link Layers.strict | strict}. No layers forbids every other layer
+     * to import it.
+     *
+     * This is about the layers only. To keep every other file away as well, add a rule with
+     * {@link ScopedRule.mustOnlyBeImportedBy}.
+     */
+    mayOnlyBeImportedBy(layer: string, ...layers: string[]): Layers;
+    /**
+     * Each of these files must be in a layer. A new file then cannot stay out of the
+     * architecture unseen. Leave out the files that belong to no layer, such as the entry
+     * point: `allExcept("src/main.ts")`.
+     */
+    everyFileInALayer(files: AnyOf<string> | Files): Layers;
+    /**
+     * The rules of the layers: one `mustNotImport` rule for each layer that must not import
+     * some other layers, and the rule of {@link Layers.everyFileInALayer} when it is given.
+     *
+     * The rule of a layer has the name of the layers and the name of the layer. It is
+     * `<layers>: <layer> does not import the layers above it` when only the order of the
+     * layers applies to the layer, and `<layers>: <layer> imports only the layers it may
+     * import` when more applies.
+     *
+     * Throws an {@link ArchitectureError} of type `malformed` when the layers cannot fail as
+     * written or name a layer that does not exist.
+     */
+    rules(): ImportRule[];
+    /** The rule with the filters of the layers. A rule that looks at no import gets only the filters that are not about imports. */
+    private withFilters;
+    /**
+     * A diagram of the layers, in Mermaid (the default) or DOT, from the top to the bottom. Each
+     * layer is a node, and an edge is an import between two layers. An import that the layers
+     * forbid is red. A file is in the first layer that matches it, and a file in no layer is
+     * not drawn. The files of {@link Layers.everyFileInALayer} are not checked.
+     *
+     * Throws an {@link ArchitectureError}: `malformed` as {@link Layers.rules} does, or
+     * `invalid` when a pattern of a layer matches no file.
+     *
+     * ```ts
+     * const text = layers("the layers").layer("ui", "src/ui/**").layer("db", "src/db/**").diagram(app);
+     * writeFileSync("docs/layers.md", `\`\`\`mermaid\n${text}\`\`\`\n`);
+     * ```
+     */
+    diagram(project: Project, format?: DiagramFormat): string;
+    /** For each layer, by position from the top, the layers it may import; or every problem of the layers. */
+    private allowed;
+    private with;
+}
+/** Starts a set of layers. Add the layers from the top to the bottom. */
+export declare function layers(name: string): Layers;
+export {};