@codependix/configuration 0.0.0-stage → 0.0.3

package/dist/src/index.d.ts

@@ -0,0 +1,1232 @@
+import { RunMode } from '@codependix/core';
+import { RunModeSelection } from '@codependix/core';
+import { z } from 'zod';
+
+/** Arguments accepted when applying `--include`/`--exclude` overrides. */
+export declare interface ApplyOverridesArguments {
+    /** The configuration exactly as parsed, before any default is applied. */
+    authored: CodependixConfiguration;
+    overrides: CodependixConfigurationOverrides | undefined;
+    /** The configuration with every default already applied. */
+    resolved: ResolvedCodependixConfiguration;
+}
+
+/** What `--check boundaries` asks the run to fail on: an edge breaking a rule. */
+export declare const CHECK_BOUNDARIES = "boundaries";
+
+/**
+ * Everything `--check` accepts, in the order an error message lists them.
+ *
+ * Named here rather than spelled into each message, so the list a mistake is
+ * measured against and the list it is told about can never drift apart. The
+ * same arrangement `codometer` and `callidescope` both use, and `reports` is
+ * deliberately their word spelled the same way: a configured destination has
+ * gone stale is one finding across all three tools, and two names for it
+ * would make the three reports unreadable together.
+ */
+export declare const CHECK_NAMES: string[];
+
+/** What `--check reports` asks the run to fail on: a stale configured export. */
+export declare const CHECK_REPORTS = "reports";
+
+/** How a `--check` value is written: one comma-separated set, no spaces needed. */
+export declare const CHECK_SEPARATOR = ",";
+
+/** Export targets a graph type may be configured with, per project. */
+export declare const CODEPENDIX_EXPORT_TARGETS: readonly ["both", "json", "markdown", "none"];
+
+/** Graph levels codependix can build. */
+export declare const CODEPENDIX_GRAPH_TYPES: readonly ["fileImports", "nestjsModules", "nxProjects"];
+
+/**
+ * Every declared boundary rule, keyed by the graph level it judges.
+ *
+ * Keyed the same way `CodependixProjectConfiguration` is, and written out
+ * field by field for the same reason: under `exactOptionalPropertyTypes`,
+ * `Partial<Record<...>>` makes a field optional without widening its type to
+ * include `undefined`, which then rejects the "unset" value every
+ * default-resolution path needs to assign.
+ *
+ * A flat array with a `graph` discriminant would also work, and was rejected:
+ * it forces a reader to know which selector keys are legal at which level,
+ * which the key already says.
+ *
+ * `fileImports` nests by language rather than flattening to one rule array:
+ * a Python file cannot import a TypeScript file or vice versa, so no edge
+ * ever crosses languages, and the rule vocabularies genuinely differ (a
+ * `*.types.ts` naming convention has no Python equivalent). `nestjsModules`
+ * and `nxProjects` keep the flat shape every other level always had.
+ */
+export declare interface CodependixBoundariesConfiguration {
+    fileImports?: CodependixFileImportsBoundariesConfiguration | undefined;
+    nestjsModules?: CodependixBoundaryRule[] | undefined;
+    nxProjects?: CodependixBoundaryRule[] | undefined;
+}
+
+/**
+ * One rule stating which nodes may reach which, at one graph level.
+ *
+ * `forbid` reports every edge whose source matches `from` and whose target
+ * matches `to`. `allow` reports the mirror image — an edge leaving `from` for
+ * anywhere `to` does not claim — so it states a node's whole permitted
+ * surface rather than one thing it may not touch. Written as two `kind`s of
+ * one rule rather than two rule types, because a reader comparing them wants
+ * to see the same three fields either way.
+ */
+export declare interface CodependixBoundaryAccessRule {
+    /**
+     * Narrows which edges the rule judges, rather than which nodes it selects.
+     *
+     * Left unset, the rule judges every edge between the nodes it selects.
+     */
+    edges?: CodependixBoundaryEdgeSelector | undefined;
+    /** Selects the nodes the edge leaves. */
+    from: CodependixBoundarySelector;
+    kind: "allow" | "forbid";
+    /**
+     * Why the rule exists, appended to the generated sentence.
+     *
+     * Appended rather than substituted, so no wording a configuration chooses
+     * can cost a report the rule that fired and both ends of what it fired on.
+     */
+    message?: string | undefined;
+    /** How the rule is named in a report, and in whatever asks about it. */
+    name: string;
+    /** Selects the nodes the edge arrives at. */
+    to: CodependixBoundarySelector;
+}
+
+/**
+ * One rule forbidding a cycle among a selected set of nodes.
+ *
+ * Deliberately narrow at TypeScript file level, where `dependency-cruiser`'s
+ * `no-circular` is already the workspace's gate — see
+ * `configuration/dependency-cruiser.cjs`. At Nx project level and NestJS
+ * module level nothing else states it, which is where this earns its place.
+ */
+export declare interface CodependixBoundaryAcyclicRule {
+    kind: "acyclic";
+    /** Why the rule exists, appended to the generated sentence. */
+    message?: string | undefined;
+    /** How the rule is named in a report, and in whatever asks about it. */
+    name: string;
+    /**
+     * Selects the nodes the rule covers, defaulting to every node in the graph.
+     *
+     * A cycle is only reported when every node in it is selected: a rule scoped
+     * to one directory should not fail because of a cycle running through code
+     * it was never asked about.
+     */
+    nodes?: CodependixBoundarySelector | undefined;
+}
+
+/**
+ * How a rule narrows which edges it judges.
+ *
+ * Separate from `CodependixBoundarySelector`, which picks the nodes at either
+ * end: this is about the edge itself, and only the Nx level draws an edge with
+ * an attribute worth narrowing on.
+ */
+export declare interface CodependixBoundaryEdgeSelector {
+    /**
+     * Judge only implicit edges, or only explicit ones.
+     *
+     * `false` is what makes a rule mean exactly what an
+     * `@nx/enforce-module-boundaries` `depConstraint` means: that rule reads
+     * import statements, so an `implicitDependencies` entry is invisible to it.
+     * `true` inverts it — useful for finding the edges declared in
+     * configuration that no import backs. Unset judges both, which is the
+     * stricter reading and the right default for a rule about what a project
+     * may depend on rather than about what it may import.
+     *
+     * Every level that is not `nx` draws only explicit edges, so a rule naming
+     * `implicit: true` there selects nothing.
+     */
+    implicit?: boolean | undefined;
+}
+
+/** One declared rule, of either kind. */
+export declare type CodependixBoundaryRule = CodependixBoundaryAccessRule | CodependixBoundaryAcyclicRule;
+
+/**
+ * How a rule picks the nodes at one end of an edge.
+ *
+ * Four vocabularies, one node shape: an Nx project is selected by name or by
+ * tag, a file by its project-relative path, a NestJS module only by its class
+ * name — see `NestjsModuleGraph`, which carries no file path at all. Every
+ * field is a list of globs, matched with `path.matchesGlob`, and a node
+ * matches the selector when it matches every field the selector states.
+ * Within one field, one glob matching is enough.
+ *
+ * A selector stating no field at all is refused rather than read as "every
+ * node": the two are indistinguishable in a configuration file, and reading
+ * it as everything turns a typo into a rule that judges the whole workspace.
+ */
+export declare interface CodependixBoundarySelector {
+    /** Globs matched against the node's identifier. */
+    id?: string[] | undefined;
+    /** Globs matched against the node's path, where its level carries one. */
+    path?: string[] | undefined;
+    /** Globs matched against the Nx project the node belongs to. */
+    project?: string[] | undefined;
+    /** Globs matched against the node's Nx tags; one tag matching is enough. */
+    tags?: string[] | undefined;
+}
+
+/**
+ * Configuration authored in a `codependix.config.ts` file.
+ *
+ * Every field is optional: a workspace with no configuration file at all
+ * resolves every graph type for every project to `target: "none"`, so
+ * codependix produces nothing until it is told where to write.
+ */
+export declare interface CodependixConfiguration {
+    /**
+     * Rules every built graph is judged against, keyed by graph level.
+     *
+     * Separate from a project's own `codependix.config.ts`, which says where
+     * that project's export is written: a rule has no destination, and a
+     * violation is reported to the console and the exit code rather than
+     * published anywhere.
+     */
+    boundaries?: CodependixBoundariesConfiguration | undefined;
+    /** Project names or roots excluded from every graph, as globs. */
+    exclude?: string[] | undefined;
+    /** Project names or roots participating in graph export, as globs. */
+    include?: string[] | undefined;
+    /**
+     * A project graph to read instead of resolving the working directory's.
+     *
+     * A path, relative to the workspace root, to the JSON `nx graph
+     * --file=graph.json` emits. Nx resolves a project graph from the process
+     * working directory and takes no directory argument, so this is the only
+     * way to graph a workspace the process is not standing in — a CI job that
+     * checked out one repository and graphs another, or a test with no Nx
+     * workspace under it.
+     *
+     * A supplied graph's node roots are workspace-relative and resolve against
+     * the same root every export path does.
+     */
+    projectGraph?: string | undefined;
+    /**
+     * Export configuration for the whole-workspace Workspace Graph.
+     *
+     * Separate from `defaults`/`projects`: the Workspace Graph is exported once
+     * for the entire repository rather than once per project, so it carries no
+     * per-project override and is unaffected by `include`/`exclude`.
+     *
+     * `--projects` and `--tags` do reach it: a run naming a selection narrows
+     * the graph's node set to the projects it named. Its destination is still
+     * read from `workspace` either way.
+     */
+    workspace?: CodependixWorkspaceConfiguration | undefined;
+}
+
+/**
+ * Strict, per-field CLI overrides for a run's root configuration.
+ *
+ * Mirrors `@callidescope/configuration`'s override philosophy exactly: a
+ * field may be overridden only when the configuration this run reads already
+ * declared it — see `ConfigurationService.loadConfiguration`. An empty list is
+ * read the same as the field being left off entirely, matching how
+ * `--directories`/`--exclude` treat an empty list in callidescope.
+ */
+export declare interface CodependixConfigurationOverrides {
+    /** Overrides `exclude` for this run. */
+    exclude?: string[] | undefined;
+    /** Overrides `include` for this run. */
+    include?: string[] | undefined;
+}
+
+/**
+ * Validates a codependix configuration file's contents.
+ *
+ * Zod strips unknown keys rather than rejecting them, so a configuration
+ * written for a newer codependix still loads under an older one instead of
+ * failing on a field it has no opinion about.
+ */
+export declare const codependixConfigurationSchema: z.ZodObject<{
+    boundaries: z.ZodOptional<z.ZodObject<{
+        fileImports: z.ZodOptional<z.ZodObject<{
+            python: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                edges: z.ZodOptional<z.ZodObject<{
+                    implicit: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                from: z.ZodObject<{
+                    id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    allow: "allow";
+                    forbid: "forbid";
+                }>;
+                message: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                to: z.ZodObject<{
+                    id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"acyclic">;
+                message: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                nodes: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>]>>>;
+            typescript: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                edges: z.ZodOptional<z.ZodObject<{
+                    implicit: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                from: z.ZodObject<{
+                    id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    allow: "allow";
+                    forbid: "forbid";
+                }>;
+                message: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                to: z.ZodObject<{
+                    id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"acyclic">;
+                message: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                nodes: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>]>>>;
+        }, z.core.$strip>>;
+        nestjsModules: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            edges: z.ZodOptional<z.ZodObject<{
+                implicit: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            from: z.ZodObject<{
+                id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            kind: z.ZodEnum<{
+                allow: "allow";
+                forbid: "forbid";
+            }>;
+            message: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            to: z.ZodObject<{
+                id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"acyclic">;
+            message: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            nodes: z.ZodOptional<z.ZodObject<{
+                id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>>;
+        nxProjects: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            edges: z.ZodOptional<z.ZodObject<{
+                implicit: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            from: z.ZodObject<{
+                id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            kind: z.ZodEnum<{
+                allow: "allow";
+                forbid: "forbid";
+            }>;
+            message: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            to: z.ZodObject<{
+                id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"acyclic">;
+            message: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            nodes: z.ZodOptional<z.ZodObject<{
+                id: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                project: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>>;
+    }, z.core.$strip>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    projectGraph: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        fileImports: z.ZodOptional<z.ZodObject<{
+            json: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strip>>;
+            markdown: z.ZodOptional<z.ZodObject<{
+                anchor: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            target: z.ZodOptional<z.ZodEnum<{
+                both: "both";
+                json: "json";
+                markdown: "markdown";
+                none: "none";
+            }>>;
+        }, z.core.$strip>>;
+        nestjsModules: z.ZodOptional<z.ZodObject<{
+            json: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strip>>;
+            markdown: z.ZodOptional<z.ZodObject<{
+                anchor: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            target: z.ZodOptional<z.ZodEnum<{
+                both: "both";
+                json: "json";
+                markdown: "markdown";
+                none: "none";
+            }>>;
+        }, z.core.$strip>>;
+        nxProjects: z.ZodOptional<z.ZodObject<{
+            json: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strip>>;
+            markdown: z.ZodOptional<z.ZodObject<{
+                anchor: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            target: z.ZodOptional<z.ZodEnum<{
+                both: "both";
+                json: "json";
+                markdown: "markdown";
+                none: "none";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Where a graph type's export lands for a project.
+ *
+ * `both` writes the JSON and the Markdown export together. Named explicitly
+ * rather than inferred from which destinations are configured, so a project
+ * carrying a `json` destination it does not want written yet can leave it in
+ * place with the target set to `markdown`.
+ */
+export declare type CodependixExportTarget = "both" | "json" | "markdown" | "none";
+
+/**
+ * `boundaries.fileImports`'s rules, nested by language.
+ *
+ * Separate from `CodependixBoundariesConfiguration` so both the authored and
+ * resolved shapes (see `ResolvedCodependixFileImportsBoundariesConfiguration`)
+ * can name it once rather than repeating the two-field object inline.
+ */
+export declare interface CodependixFileImportsBoundariesConfiguration {
+    python?: CodependixBoundaryRule[] | undefined;
+    typescript?: CodependixBoundaryRule[] | undefined;
+}
+
+/** How one graph type's export is configured for a project. */
+export declare interface CodependixGraphOutput {
+    json?: CodependixJsonOutput | undefined;
+    markdown?: CodependixMarkdownOutput | undefined;
+    target?: CodependixExportTarget | undefined;
+}
+
+/** A level of dependency graph codependix can build. */
+export declare type CodependixGraphType = "fileImports" | "nestjsModules" | "nxProjects";
+
+/** Where a graph's JSON export is written. */
+export declare interface CodependixJsonOutput {
+    path: string;
+}
+
+/**
+ * Where a graph's Markdown export is written.
+ *
+ * Naming `anchor` places the export inside a named anchor block in the file at
+ * `path` — an existing Markdown file such as a project's `README.md`, defaulted
+ * to `README.md` when `path` is left out. Leaving `anchor` unset instead writes
+ * the export as the whole contents of a standalone file, whose `path` must then
+ * be given explicitly since there is no default worth guessing for it.
+ */
+export declare interface CodependixMarkdownOutput {
+    anchor?: string | undefined;
+    path?: string | undefined;
+}
+
+/**
+ * A project's export configuration, keyed by graph type.
+ *
+ * Written out field by field rather than as `Partial<Record<...>>`: under
+ * `exactOptionalPropertyTypes`, `Partial` makes a field optional without
+ * widening its type to include `undefined`, which then rejects the very
+ * "unset" value every default-resolution path needs to assign.
+ */
+export declare interface CodependixProjectConfiguration {
+    fileImports?: CodependixGraphOutput | undefined;
+    nestjsModules?: CodependixGraphOutput | undefined;
+    nxProjects?: CodependixGraphOutput | undefined;
+}
+
+/**
+ * Validates a project's own `codependix.config.ts`, keyed by graph type.
+ *
+ * The same shape a project's own file spreads `projectDefaults` into, and the
+ * same shape the root configuration's schema no longer carries — a project's
+ * export configuration is validated from its own file rather than from a root
+ * `projects` dict.
+ */
+export declare const codependixProjectConfigurationSchema: z.ZodObject<{
+    fileImports: z.ZodOptional<z.ZodObject<{
+        json: z.ZodOptional<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        markdown: z.ZodOptional<z.ZodObject<{
+            anchor: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        target: z.ZodOptional<z.ZodEnum<{
+            both: "both";
+            json: "json";
+            markdown: "markdown";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+    nestjsModules: z.ZodOptional<z.ZodObject<{
+        json: z.ZodOptional<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        markdown: z.ZodOptional<z.ZodObject<{
+            anchor: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        target: z.ZodOptional<z.ZodEnum<{
+            both: "both";
+            json: "json";
+            markdown: "markdown";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+    nxProjects: z.ZodOptional<z.ZodObject<{
+        json: z.ZodOptional<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        markdown: z.ZodOptional<z.ZodObject<{
+            anchor: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        target: z.ZodOptional<z.ZodEnum<{
+            both: "both";
+            json: "json";
+            markdown: "markdown";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * The `--projects` and `--tags` arguments as the command line captured them.
+ *
+ * Comma-separated strings rather than lists: the host captures raw option
+ * text and hands it over, and splitting it is resolution, which belongs
+ * beside the configuration file this package already parses.
+ */
+export declare interface CodependixSelectionArguments {
+    projects?: string | undefined;
+    tags?: string | undefined;
+}
+
+/**
+ * The Workspace Graph's export configuration, keyed by graph type.
+ *
+ * All three graph types are declared: `codependix-file-imports` and
+ * `codependix-nestjs-modules` each build a whole-workspace aggregate graph the
+ * same way `codependix-nx-projects` always has, spanning every project rather
+ * than one — see each package's own `workspace-graph` module.
+ */
+export declare interface CodependixWorkspaceConfiguration {
+    fileImports?: CodependixGraphOutput | undefined;
+    nestjsModules?: CodependixGraphOutput | undefined;
+    nxProjects?: CodependixGraphOutput | undefined;
+}
+
+/**
+ * File names searched for when no configuration path is given.
+ *
+ * Searched in order, so a workspace carrying both a TypeScript and a JSON
+ * configuration file gets the TypeScript one.
+ */
+export declare const CONFIGURATION_FILE_NAMES: readonly ["codependix.config.ts", "codependix.config.mts", "codependix.config.cts", "codependix.config.js", "codependix.config.mjs", "codependix.config.cjs", "codependix.config.json"];
+
+/** Raised when an explicitly named configuration file does not exist. */
+export declare class ConfigurationFileNotFoundError extends Error {
+    constructor(filePath: string);
+}
+
+/**
+ * Finds, reads, and parses codependix configuration files from disk.
+ *
+ * Kept apart from `ConfigurationService`, which resolves what a loaded
+ * configuration means for a project or a workspace: this service only ever
+ * answers "what is on disk", never "what should happen because of it".
+ */
+declare class ConfigurationLoaderService {
+    constructor();
+    /** Reads what a configuration module exported, through either interop shape. */
+    private readDefaultExport;
+    /**
+     * Walks upward from a directory looking for a configuration file.
+     *
+     * Returns `undefined` when the search reaches the filesystem root without
+     * finding one: a workspace that never wrote a configuration file resolves
+     * every graph to `target: "none"` rather than being told to write one.
+     */
+    findConfigurationFile(searchDirectory: string): string | undefined;
+    /**
+     * Looks for a project's own configuration file, exactly at its root.
+     *
+     * Unlike `findConfigurationFile`, this never walks upward: a project's own
+     * file must be colocated with it, and walking upward would find the
+     * workspace root's configuration — or another project's, in a nested
+     * layout — instead of correctly reporting that this project has none.
+     */
+    findProjectConfigurationFile(projectRoot: string): string | undefined;
+    /**
+     * Walks upward from the process cwd looking for the workspace root.
+     *
+     * Used to resolve a configuration path given relative to that root even when
+     * the command was invoked from a nested directory, which is what a task
+     * runner does whenever it sets the cwd to a project rather than the
+     * workspace.
+     */
+    findWorkspaceRoot(): string | undefined;
+    /** Loads a configuration module, choosing the reader by extension. */
+    loadConfigurationModule(args: {
+        configurationPath: string;
+        extension: string;
+    }): Promise<unknown>;
+    /** Loads and validates one configuration file at a resolved path. */
+    parseConfigurationFile(resolvedPath: string): Promise<CodependixConfiguration>;
+    /** Reads the root configuration file, or `{}` when none is found. */
+    readAuthoredConfiguration(args: {
+        configurationPath?: string | undefined;
+        searchDirectory?: string | undefined;
+    }): Promise<CodependixConfiguration>;
+    /** Resolves a configuration path against the cwd, then the workspace root. */
+    resolveConfigurationPath(configurationPath: string): string;
+}
+
+/**
+ * Provides everything one run is configured by: the configuration file, the
+ * command line resolved over it, and each project's own resolved output.
+ *
+ * `ConfigurationService` is the only thing this module exports, and the only
+ * service `@codependix/configuration` makes public. File loading, override
+ * resolution, option parsing, and run-mode selection are providers here
+ * rather than modules of their own, so a caller asking what a run is
+ * configured to do has exactly one place to ask.
+ */
+export declare class ConfigurationModule {
+}
+
+/**
+ * Loads, validates, and resolves codependix configuration files.
+ *
+ * Loading and per-project resolution are kept apart on purpose: a project's
+ * actual export configuration depends on both the global defaults and its own
+ * name, so resolving it eagerly for every project in the workspace would mean
+ * redoing that work for a workspace whose graphs run against a filtered subset
+ * of projects. `resolveForProject` is called once per project that is
+ * actually built instead.
+ */
+export declare class ConfigurationService {
+    private readonly configurationLoaderService;
+    private readonly flagResolutionService;
+    private readonly inputService;
+    private readonly overrideResolutionService;
+    constructor(configurationLoaderService: ConfigurationLoaderService, flagResolutionService: FlagResolutionService, inputService: InputService, overrideResolutionService: OverrideResolutionService);
+    /** Whether `--projects` or `--tags` names a project. */
+    private isProjectNamedOnCommandLine;
+    /** Whether a project's name matches at least one of a list of globs. */
+    private matchesAnyGlob;
+    /** Whether a project's name or its root matches at least one glob. */
+    private matchesAnyName;
+    /**
+     * Fills in every graph level a `boundaries` block may leave out.
+     *
+     * Every level resolves to a list rather than to `undefined`, so a caller
+     * walks all of them without asking which ones were configured — the same
+     * reason `include` resolves to a list nobody wrote. `fileImports` resolves
+     * both of its languages the same way, one level deeper.
+     */
+    private resolveBoundaries;
+    /** Applies defaults to one graph type's export configuration. */
+    private resolveGraphOutput;
+    /**
+     * Splits the `--projects` and `--tags` arguments into lists.
+     *
+     * Empty entries are dropped, so a trailing comma and a doubled one are both
+     * read as the author meant them rather than as a glob matching nothing.
+     */
+    private resolveSelection;
+    /** Splits one comma-separated argument, trimming and dropping blanks. */
+    private splitSelectionArgument;
+    /**
+     * Whether a project participates in graph export at all.
+     *
+     * A project matches when something claims it — an `include` glob, a
+     * `--projects` glob, or a `--tags` tag — and no `exclude` glob claims its
+     * name or root. The command line **widens** what the configuration already
+     * selects rather than replacing it; `exclude` wins over all three, because
+     * a flag that could resurrect an excluded project would make `exclude`
+     * advisory.
+     *
+     * `projectRoot` and `projectTags` are optional: a caller with neither handy
+     * still resolves against globs written against project names.
+     */
+    isProjectIncluded(args: ProjectSelectionArguments): boolean;
+    /**
+     * Whether a project is in the set a run's command line narrowed to.
+     *
+     * A run naming no selection selects **everything**, which is what keeps the
+     * whole-workspace graph and the boundary gate judging every project by
+     * default. Naming one narrows both to what it named.
+     *
+     * This is where `--projects`/`--tags` differ from `include`: `include` is
+     * about which projects have exports written for them, and never reaches the
+     * workspace graph or the gate. A selection reaches all three.
+     */
+    isProjectSelected(args: ProjectSelectionArguments): boolean;
+    /**
+     * Loads and validates a codependix configuration file.
+     *
+     * A path that was named explicitly must exist — a typo in a task runner's
+     * arguments should fail rather than quietly resolving every graph to
+     * `target: "none"`. A path that was not named is searched for from the
+     * search directory upward, and its absence is legal.
+     */
+    loadConfiguration(args?: LoadConfigurationArguments): Promise<ResolvedCodependixConfiguration>;
+    /**
+     * Loads and validates one project's own `codependix.config.ts`, or
+     * `undefined` when it has none.
+     *
+     * Searched for exactly at `projectRoot` — see
+     * `ConfigurationLoaderService.findProjectConfigurationFile` — rather than
+     * the upward search `loadConfiguration` performs for the workspace root's
+     * own file: a project's file is either colocated with it or it does not
+     * exist, and a project with none produces no per-project output rather than
+     * inheriting one from a parent directory.
+     */
+    loadProjectConfiguration(args: LoadProjectConfigurationArguments): Promise<CodependixProjectConfiguration | undefined>;
+    /**
+     * Parses a comma-separated list option, dropping blank entries.
+     *
+     * One of the six command-line methods this service forwards to the
+     * `input` and flag-resolution providers it owns. They are stated here
+     * rather than exported alongside it because this package makes exactly one
+     * service public: a host asking what a run is configured to do — from its
+     * configuration file or from its flags — asks `ConfigurationService`.
+     */
+    parseCommaDelimitedOption(value: string | undefined): string[];
+    /** Parses a valueless boolean flag, which is present or it is not. */
+    parseFlagOption(value: boolean | undefined): boolean;
+    /** Trims an optional string option, treating blank as absent. */
+    parseOptionalOption(value: string | undefined): string | undefined;
+    /** Parses a path option that falls back to the working directory. */
+    parsePathOption(value: string | undefined): string;
+    /**
+     * Fills in every field a configuration file may leave out.
+     *
+     * Exposed so a host embedding codependix can hand over a configuration
+     * object it assembled itself and get the same shape a configuration file
+     * produces.
+     */
+    resolveConfiguration(configuration: CodependixConfiguration, selection?: CodependixSelectionArguments): ResolvedCodependixConfiguration;
+    /**
+     * Resolves one project's export configuration for one graph type.
+     *
+     * A project's own `codependix.config.ts`, when it has one, is read exactly
+     * as loaded — no merge against a workspace-wide default happens here, since
+     * spreading the root-exported `projectDefaults` already happened when the
+     * project's own file was authored. A project excluded by the configured
+     * `include`/`exclude` globs, or one that has no configuration file of its
+     * own at all, always resolves to `target: "none"`: the former because a
+     * project excluded from graph export should not need every field rewritten
+     * to `"none"` by hand, the latter because a project matched by `include`
+     * with no file of its own has nothing to export, even though it still
+     * contributes to the Workspace Graph and is judged by boundary rules.
+     */
+    resolveForProject(args: ResolveForProjectArguments): ResolvedCodependixGraphOutput;
+    /**
+     * Resolves the Workspace Graph's export configuration for one graph type.
+     *
+     * A Workspace Graph is exported once for the whole repository rather than
+     * once per project, so it has no per-project override and is unaffected by
+     * `include`/`exclude` — those two apply only to `resolveForProject`.
+     *
+     * `--projects` and `--tags` do reach it, through the node set rather than
+     * through this: a run naming a selection draws the graph over the projects
+     * it named. Where that graph lands is still read from `workspace`, keyed by
+     * `graphType`.
+     */
+    resolveForWorkspace(configuration: ResolvedCodependixConfiguration, graphType: CodependixGraphType): ResolvedCodependixGraphOutput;
+    /**
+     * Reads the flags into what the run writes and what it fails on.
+     *
+     * See `FlagResolutionService.selectMode` for which combinations are
+     * refused and why.
+     */
+    selectMode(options: MapCommandOptions): Promise<RunModeSelection>;
+    /** Whether a run reads or rewrites the files its exports live in. */
+    touchesFiles(mode: RunMode): boolean;
+}
+
+/** Export target applied to a graph type naming none. */
+export declare const DEFAULT_EXPORT_TARGET: CodependixExportTarget;
+
+/**
+ * Projects that participate in graph export when a configuration names none.
+ *
+ * Deliberately empty: participation is always declared. A configuration that
+ * names `defaults` but no `include` exports nothing rather than quietly
+ * covering the whole workspace, which is what lets a later widening argument
+ * mean something — a union with `["**"]` as its base can never add a project.
+ */
+export declare const DEFAULT_INCLUDE_GLOBS: readonly [];
+
+/** Markdown file an anchor-mode destination writes into when it names none. */
+export declare const DEFAULT_MARKDOWN_PATH = "README.md";
+
+/**
+ * Reads the command line into what the run will do.
+ *
+ * Internal to the `configuration` module rather than a module of its own:
+ * resolving the command line is half of answering "what is this run actually
+ * configured to do", and `ConfigurationService` is the one public way to ask.
+ * `codometer-cli` and `callidescope-cli` still carry a `run-plan` module of
+ * this shape inside their hosts — and, deliberately, the same `--check
+ * reports` spelling, since a stale configured destination is one finding
+ * across all three.
+ */
+declare class FlagResolutionService {
+    private readonly inputService;
+    constructor(inputService: InputService);
+    /** States what `--check` accepts, in front of whatever went wrong. */
+    private describeAcceptedCheckNames;
+    /** The mode nothing was selected for, so an error path has one to return. */
+    private emptyMode;
+    /**
+     * Asks which of the three things a run with no flags at all should do.
+     *
+     * Nothing is inferred: a session that cannot be asked fails rather than
+     * defaulting to a write nobody requested, and a run that quietly did
+     * nothing and exited 0 is worse than either.
+     */
+    private promptForMode;
+    /**
+     * Reads the `--check` value into the set of things the run fails on.
+     *
+     * A flag passed without a value arrives as `true` and is a mistake rather
+     * than a shorthand: read as "gate nothing" it would be a gate that cannot
+     * fail, and `--check "$GATES"` with the variable unset would pass forever
+     * over a workspace whose every rule was broken — worse than no gate at all,
+     * because it looks like protection.
+     */
+    private readCheckNames;
+    /** Keeps the names `--check` knows and complains about the rest. */
+    private validateCheckNames;
+    /**
+     * Reads the flags into what the run writes and what it fails on.
+     *
+     * `--write --check reports` is refused rather than obeyed: nothing can be
+     * stale immediately after being written, so a run asking for both has
+     * misunderstood one of them and would pass whatever it was meant to catch.
+     * `--write --check boundaries` is legal for the mirror-image reason — a
+     * boundary has no destination to be stale, so writing every export and
+     * judging every graph in one run is two independent things, not a
+     * contradiction.
+     */
+    selectMode(options: MapCommandOptions): Promise<RunModeSelection>;
+    /**
+     * Whether a run reads or rewrites the files its exports live in.
+     *
+     * `--check boundaries` alone reads no destination and writes nothing, so it
+     * leaves every committed export exactly as it found it — which is what
+     * makes it safe on a branch, where the exports are expected to be behind.
+     */
+    touchesFiles(mode: RunMode): boolean;
+}
+
+/**
+ * Thrown when a command line cannot be turned into a run.
+ *
+ * One class rather than one per cause: every cause is the same event to
+ * whoever catches it — nothing was attempted, and the fix is to retype the
+ * flags. Only the wording varies, which is what the factories below do.
+ *
+ * Sits beside the constants because that is where every error class in this
+ * repository lives — the project structure rule has no `errors` suffix, and
+ * the Constant File Shape rule whitelists `class X extends Error` for exactly
+ * this.
+ */
+export declare class InputError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Parses CLI option values and asks for the ones a command still needs.
+ *
+ * Lives here rather than in `codependix-cli` so the shared flag rules are
+ * stated once, beside the configuration those flags select. Mirrors
+ * `@callidescope/configuration`'s `InputService`.
+ */
+declare class InputService {
+    constructor();
+    /** Overridable so tests never touch a real terminal. */
+    private readonly promptRunner;
+    /**
+     * Refuses to draw a prompt nobody can answer.
+     *
+     * `prompts` does not fail on a non-terminal stdin — it renders the menu,
+     * never resolves, and lets the process exit 0, so a run that did nothing
+     * reads as one that succeeded. `isTTY` is read as falsy rather than
+     * coerced: `@types/node` calls it a `boolean`, so lint rejects a coercion.
+     */
+    private assertCanPrompt;
+    /**
+     * Parses a comma-separated list option, dropping blank entries.
+     *
+     * Mirrors `@callidescope/configuration`'s `InputService` exactly: an absent
+     * flag resolves to an empty list rather than `undefined`, so a caller
+     * overriding a configured list treats "the flag was left off" and "the flag
+     * named nothing" the same way.
+     */
+    parseCommaDelimitedOption(value: string | undefined): string[];
+    /**
+     * Parses a valueless boolean flag, which is present or it is not.
+     *
+     * Commander passes `undefined` for a flag carrying no value, so the flag
+     * appearing at all is what makes it true; reading that as false would turn
+     * every such flag permanently off.
+     */
+    parseFlagOption(value: boolean | undefined): boolean;
+    /** Trims an optional string option, treating blank as absent. */
+    parseOptionalOption(value: string | undefined): string | undefined;
+    /**
+     * Parses a path option that falls back to the working directory.
+     *
+     * Left unresolved: the caller resolves it against its own root, and
+     * resolving twice makes a relative path ambiguous about which it meant.
+     */
+    parsePathOption(value: string | undefined): string;
+    /** Prompts for one value out of a fixed set of choices. */
+    promptForSelect<Choice extends string>(args: {
+        choices: readonly Choice[];
+        message: string;
+        subject: string;
+    }): Promise<Choice>;
+}
+
+/** Arguments accepted when loading a configuration file. */
+export declare interface LoadConfigurationArguments {
+    configurationPath?: string | undefined;
+    /** Strict per-field CLI overrides, applied after the file is resolved. */
+    overrides?: CodependixConfigurationOverrides | undefined;
+    searchDirectory?: string | undefined;
+    /** Command-line project selection, unparsed — see `CodependixSelectionArguments`. */
+    selection?: CodependixSelectionArguments | undefined;
+}
+
+/** Arguments accepted when loading one project's own configuration file. */
+export declare interface LoadProjectConfigurationArguments {
+    /** The project's root, absolute or resolved against the process cwd. */
+    projectRoot: string;
+}
+
+/** Command-line options `codependix` accepts. */
+export declare interface MapCommandOptions {
+    /**
+     * The set of findings `--check` gates, unparsed.
+     *
+     * `true` is the flag written with no value at all, which is refused rather
+     * than read as a shorthand — see `ConfigurationService.selectMode`.
+     */
+    check?: string | true | undefined;
+    config?: string | undefined;
+    directory?: string | undefined;
+    /** Overrides `exclude` for this run. Refused when never configured. */
+    exclude?: string[] | undefined;
+    /**
+     * Builds, checks, and writes the `fileImports` graph type for this run.
+     *
+     * `undefined` when neither `--file-imports` nor `--no-file-imports` was
+     * given, which leaves the graph type enabled — the behavior every run had
+     * before this flag existed.
+     */
+    fileImports?: boolean | undefined;
+    /**
+     * What `--format` prints to standard output, unparsed.
+     *
+     * Defaults to `"markdown"` when the flag was left off entirely — unlike
+     * codometer's `--format`, which falls back to a resolved configuration
+     * field, codependix's configuration declares no such field, so the default
+     * is a fixed constant instead.
+     */
+    format?: string | undefined;
+    /** Overrides `include` for this run. Refused when never configured. */
+    include?: string[] | undefined;
+    /**
+     * Writes every active graph type's data, combined into one JSON file at
+     * this path, keyed by graph type name.
+     */
+    jsonOutput?: string | undefined;
+    /**
+     * Writes every active graph type's rendered diagram, combined into one
+     * Markdown file at this path — each type's own anchor-spliced section,
+     * the same splicing `DeliveryService` applies per project, applied here to
+     * one shared destination instead.
+     */
+    markdownOutput?: string | undefined;
+    /** Builds, checks, and writes the `nestjsModules` graph type for this run. */
+    nestjsModules?: boolean | undefined;
+    /** Builds, checks, and writes the `nxProjects` graph type for this run. */
+    nxProjects?: boolean | undefined;
+    /**
+     * Projects to export for beyond what `include` already selects, unparsed.
+     *
+     * Comma-separated globs matched against a project's name or its
+     * workspace-relative root.
+     */
+    projects?: string | undefined;
+    /** Nx tags to export for beyond what `include` selects, unparsed. */
+    tags?: string | undefined;
+    write?: boolean | undefined;
+}
+
+/**
+ * A required value that cannot be asked for, because stdin is not a terminal.
+ *
+ * `prompts` does not fail there — it draws its menu, never resolves, and the
+ * process exits 0 having done nothing. This refuses to become that silent
+ * green no-op.
+ */
+export declare const missingInputError: (subject: string) => InputError;
+
+/**
+ * Applies strict, per-field CLI overrides to an already-resolved
+ * configuration.
+ *
+ * Mirrors `@callidescope/configuration`'s `FlagResolutionService` philosophy
+ * exactly: a flag may override a value the configuration already declares,
+ * and is refused when the configuration never declared that field at all.
+ * Kept apart from `ConfigurationService` so the resolution logic — and the
+ * file-length budget it would otherwise share with loading, boundary
+ * defaulting, and per-project resolution — is stated and tested once, on its
+ * own.
+ */
+declare class OverrideResolutionService {
+    constructor();
+    /**
+     * Applies one list override, refusing it when the author never declared
+     * the field it names.
+     *
+     * Checked against `authored` — the configuration exactly as parsed, before
+     * `include`/`exclude` are defaulted — rather than against the resolved
+     * value: `ConfigurationService.resolveConfiguration` fills in
+     * `DEFAULT_INCLUDE_GLOBS`/`[]` for a field the author never wrote, so the
+     * resolved value is never itself `undefined`. Checking there would make
+     * every override legal regardless of what the configuration actually
+     * declared, which is the opposite of the precedence rule this mirrors.
+     *
+     * An empty override list is read the same as no override at all.
+     */
+    private resolveOverride;
+    /**
+     * Applies `--include`/`--exclude` on top of an already-resolved
+     * configuration.
+     */
+    applyOverrides(args: ApplyOverridesArguments): ResolvedCodependixConfiguration;
+}
+
+/** Arguments accepted when resolving one project's export configuration. */
+export declare interface ProjectSelectionArguments {
+    configuration: ResolvedCodependixConfiguration;
+    projectName: string;
+    /**
+     * The project's root, relative to the workspace, as read from the Nx
+     * project graph.
+     *
+     * Optional so a caller with no root handy — a test, or a host that only
+     * knows a project by name — still resolves against `include`/`exclude`
+     * globs written against project names.
+     */
+    projectRoot?: string | undefined;
+    /**
+     * The project's own Nx tags, for matching `--tags`.
+     *
+     * Optional for the same reason `projectRoot` is: a caller that knows a
+     * project only by name still resolves against everything else.
+     */
+    projectTags?: string[] | undefined;
+}
+
+/**
+ * A prompt someone dismissed without answering.
+ *
+ * Worded apart from a prompt that resolved to something unrecognized:
+ * pressing escape is ordinary, and reporting it as a crash sends the reader
+ * debugging for nothing.
+ */
+export declare const promptCancelledError: (subject: string) => InputError;
+
+/**
+ * Marks the workspace root during an upward search from the process cwd.
+ *
+ * A package manifest is deliberately not one of them: every project in the
+ * workspace carries one, so the search would stop at the nearest project
+ * rather than the root a configuration path was written relative to.
+ */
+export declare const REPOSITORY_ROOT_MARKERS: readonly [".git", "pnpm-workspace.yaml"];
+
+/**
+ * Every graph level's declared rules, with a level naming none resolved to an
+ * empty list rather than left unset — so a caller iterates every level
+ * without asking whether each one was configured.
+ */
+export declare interface ResolvedCodependixBoundariesConfiguration {
+    fileImports: ResolvedCodependixFileImportsBoundariesConfiguration;
+    nestjsModules: CodependixBoundaryRule[];
+    nxProjects: CodependixBoundaryRule[];
+}
+
+/**
+ * Configuration with every default applied.
+ *
+ * Carries no per-project state at all: a project's own export configuration
+ * lives in its own colocated `codependix.config.ts`, loaded on demand by
+ * `ConfigurationService.loadProjectConfiguration` and handed to
+ * `resolveForProject` — which is also where `include` and `exclude` globs
+ * are applied.
+ */
+export declare interface ResolvedCodependixConfiguration {
+    boundaries: ResolvedCodependixBoundariesConfiguration;
+    exclude: string[];
+    include: string[];
+    /** A project graph to read instead of the working directory's, if named. */
+    projectGraph: string | undefined;
+    /**
+     * What `--projects` and `--tags` named, resolved.
+     *
+     * Carried on the resolved configuration rather than passed alongside it so
+     * that everything already handed a configuration — the export passes, the
+     * workspace graph, and the boundary gate — sees the same selection without
+     * a second argument threaded through each of them.
+     */
+    selection: ResolvedCodependixSelection;
+    workspace: CodependixWorkspaceConfiguration;
+}
+
+/** `fileImports`'s rules, resolved so both languages always resolve to a list. */
+export declare interface ResolvedCodependixFileImportsBoundariesConfiguration {
+    python: CodependixBoundaryRule[];
+    typescript: CodependixBoundaryRule[];
+}
+
+/** A graph type's export configuration with every default applied. */
+export declare interface ResolvedCodependixGraphOutput {
+    json: ResolvedCodependixJsonOutput | undefined;
+    markdown: ResolvedCodependixMarkdownOutput | undefined;
+    target: CodependixExportTarget;
+}
+
+/** JSON output destination, unresolved beyond what `CodependixJsonOutput` is. */
+export declare type ResolvedCodependixJsonOutput = CodependixJsonOutput;
+
+/** Markdown output destination with its path defaulted. */
+export declare interface ResolvedCodependixMarkdownOutput {
+    anchor: string | undefined;
+    path: string;
+}
+
+/**
+ * A run's project selection, split and trimmed.
+ *
+ * Both lists empty means no selection was made at all, which is not the same
+ * as a selection that matches nothing: an absent selection leaves the
+ * whole-workspace graph and the boundary gate judging every project, while a
+ * selection naming something narrows both to what it names.
+ */
+export declare interface ResolvedCodependixSelection {
+    /** Globs matched against a project's name or its workspace-relative root. */
+    projects: string[];
+    /** Nx tags, matched exactly against a project's own. */
+    tags: string[];
+}
+
+/** Arguments for resolving one project's export configuration. */
+export declare interface ResolveForProjectArguments extends ProjectSelectionArguments {
+    graphType: CodependixGraphType;
+    /**
+     * The project's own loaded `codependix.config.ts`, or `undefined` when it
+     * has none — see `ConfigurationService.loadProjectConfiguration`.
+     *
+     * Read as-is rather than merged with anything else: a project's own file
+     * already spreads the root-exported `projectDefaults` at authoring time, so
+     * whatever `loadProjectConfiguration` returns is the complete statement of
+     * that project's export configuration. A project naming no file of its own
+     * resolves to `target: "none"` regardless of `include`/`exclude` — it
+     * simply has nothing to export.
+     */
+    projectConfiguration: CodependixProjectConfiguration | undefined;
+}
+
+/**
+ * What a command line naming no mode at all is asked to choose between.
+ *
+ * Three choices rather than the two `--check`/`--write` used to offer, since
+ * `--check` now names which finding it gates. Kept as a prompt rather than
+ * defaulted to anything: a run that silently did nothing and exited 0 is the
+ * failure this whole flag arrangement exists to prevent.
+ */
+export declare const RUN_MODE_CHOICES: readonly ["boundaries", "reports", "write"];
+
+/** What the prompt calls the thing it is asking for, in its error messages. */
+export declare const RUN_MODE_SUBJECT = "A run mode (--check or --write)";
+
+/** Raised when the configuration path points to an unsupported file type. */
+export declare class UnknownConfigurationFileTypeError extends Error {
+    constructor(filePath: string);
+}
+
+export { }