@g3nomaly/analyze 0.0.0-stage → 0.1.0

package/dist/scanner/schema/definitions.d.ts

@@ -0,0 +1,69 @@
+import type { EdgeKind, LinkedText, NodeRef } from '../../model';
+import type { DocFile } from '../docs';
+import type { GraphBuilder } from '../graph/builder';
+import type { ProseResolvers } from '../markdown/links';
+import type { MarkdownRenderer } from '../markdown/renderer';
+import { type TypeExpression } from './describe';
+import type { DefinitionRegistry } from './registry';
+/** The file a definition is in. */
+export interface DefinitionOwner {
+    /** Node of the file. Definitions become its children. */
+    readonly ref: NodeRef;
+    readonly file: DocFile;
+    /** Anchors already used on the page of the file. */
+    readonly anchors: Set<string>;
+}
+/**
+ * Adds named JSON Schemas to the graph: one `definition` node per schema and
+ * one `field` node per property. A `$ref` in a type becomes a link to the
+ * definition it names, and an edge: `type` from a property, `extends` from a
+ * definition.
+ *
+ * Holds the graph, the markdown renderer, the prose resolvers and the
+ * definition registry. Created once per scan by `RepositoryScanner`. Used by
+ * `JsonSchemaPlanner` for the schemas of a schema file and by
+ * `OpenApiPlanner` for `components.schemas` and for the schemas of
+ * parameters, request bodies and responses.
+ *
+ * @example
+ * const registry = new DefinitionRegistry();
+ * const definitions = new DefinitionPlanner(graph, markdown, resolvers, registry);
+ */
+export declare class DefinitionPlanner {
+    private readonly graph;
+    private readonly markdown;
+    private readonly resolvers;
+    private readonly registry;
+    /**
+     * Creates a planner.
+     *
+     * @param resolvers - Links what descriptions refer to.
+     * @param registry - Receives every definition, and finds the targets of refs.
+     */
+    constructor(graph: GraphBuilder, markdown: MarkdownRenderer, resolvers: ProseResolvers, registry: DefinitionRegistry);
+    /**
+     * Adds one definition with its properties.
+     *
+     * @param name - Name of the definition, as the page shows it.
+     * @param pointer - JSON pointer of the schema inside its file. Refs to that place link to the definition.
+     * @returns The node of the definition.
+     */
+    add(owner: DefinitionOwner, name: string, pointer: string, schema: unknown): NodeRef;
+    /**
+     * Turns a type expression into text with links to the definitions its refs name.
+     *
+     * @param from - Node the expression belongs to.
+     * @param file - The file the expression is in. A relative ref starts there.
+     * @param relation - Kind of the edge each resolved ref records from `from`.
+     * @returns The text with a link for every ref the scan can resolve. A resolved ref reads as the name of its target, so a ref to a whole file reads as the title of its schema.
+     */
+    linked(expression: TypeExpression, from: NodeRef, file: DocFile, relation: EdgeKind): LinkedText;
+    /**
+     * Renders a description.
+     *
+     * @param markdown - Markdown of the description, or `''`.
+     * @param node - Node the description belongs to. Links in it become edges from this node.
+     * @returns HTML, or `''`.
+     */
+    html(markdown: string, node: NodeRef, { root, path, prefix }: DocFile): Promise<string>;
+}

package/dist/scanner/schema/describe.d.ts

@@ -0,0 +1,79 @@
+/** A JSON object as parsed from JSON or YAML. */
+export type JsonObject = Readonly<Record<string, unknown>>;
+/**
+ * Tells a JSON object from every other value: true for an object that is no
+ * array and not `null`.
+ */
+export declare function isJsonObject(value: unknown): value is JsonObject;
+/** A span of a type expression that stands for a `$ref`. */
+export interface SchemaRef {
+    readonly start: number;
+    readonly end: number;
+    /** The `$ref` as the schema writes it. */
+    readonly ref: string;
+}
+/** What a schema allows, as text: `string[]`, `Cat | Dog`, `"open" | "closed"`. */
+export interface TypeExpression {
+    readonly text: string;
+    /** In text order, not overlapping. */
+    readonly refs: readonly SchemaRef[];
+}
+/** One property of an object schema. A nested property has a dotted name. */
+export interface SchemaProperty {
+    /** `city`, `address.city`, `items[].sku`. */
+    readonly name: string;
+    readonly type: TypeExpression;
+    readonly required: boolean;
+    /** The default as JSON, or `null`. */
+    readonly defaultValue: string | null;
+    /** Markdown. */
+    readonly description: string;
+    /** Keywords that narrow the type, as `keyword: value`. */
+    readonly constraints: readonly string[];
+}
+/** What a schema says, in the shape the site shows. */
+export interface SchemaDescription {
+    readonly type: TypeExpression;
+    /** Markdown. */
+    readonly description: string;
+    readonly constraints: readonly string[];
+    /** Values of an `enum` or a `const`, as JSON. */
+    readonly values: readonly string[];
+    readonly deprecated: boolean;
+    readonly properties: readonly SchemaProperty[];
+}
+/**
+ * Reads the last part of a `$ref` as a name.
+ *
+ * @param ref - A `$ref`, such as `#/$defs/Booking` or `cargo.schema.json`.
+ * @returns `Booking` for a ref into a file, the file name for a ref to a whole file.
+ */
+export declare function refName(ref: string): string;
+/**
+ * Decodes one segment of a JSON pointer.
+ *
+ * @returns The key it names: percent escapes decoded, `~1` as `/` and `~0` as `~`.
+ */
+export declare function decodePointerSegment(segment: string): string;
+/**
+ * Writes what a schema allows as a type expression.
+ *
+ * @param schema - A schema: an object, or `true` or `false`.
+ * @param depth - Nesting of the schema inside the one that is described.
+ * @returns The expression. `any` for a schema that states no type.
+ */
+export declare function typeOf(schema: unknown, depth?: number): TypeExpression;
+/**
+ * Describes a JSON Schema in the shape the site shows: a type expression, a
+ * description, constraints and a flat list of properties.
+ *
+ * @param schema - The schema: an object, or `true` or `false`.
+ * @returns The description. A value that is no schema is described as `any`.
+ */
+export declare function describeSchema(schema: unknown): SchemaDescription;
+/**
+ * Tells whether a schema says anything about a value: true when it has a
+ * type, properties, a composition, values or a `$ref`. A file that only
+ * holds `$defs` has a root schema that does not.
+ */
+export declare function describesValue(schema: JsonObject): boolean;

package/dist/scanner/schema/planner.d.ts

@@ -0,0 +1,46 @@
+import type { NodeRef } from '../../model';
+import type { FileRenderer } from '../content';
+import type { DocFile } from '../docs';
+import type { GraphBuilder } from '../graph/builder';
+import type { ProseResolvers } from '../markdown/links';
+import type { DefinitionPlanner } from './definitions';
+import { type JsonObject } from './describe';
+import type { DefinitionRegistry } from './registry';
+/**
+ * Adds a JSON Schema file to the graph: one `schema` node for the file, with
+ * its text, and one definition per schema it names. The root schema is a
+ * definition when it describes a value.
+ *
+ * Holds the graph, the file renderer, the prose resolvers, the shared
+ * `DefinitionPlanner` and the `DefinitionRegistry`. Created by
+ * `RepositoryScanner` and used by `SpecPlanner` for every JSON or YAML file
+ * that is a JSON Schema.
+ *
+ * @example
+ * const registry = new DefinitionRegistry();
+ * const definitions = new DefinitionPlanner(graph, markdown, resolvers, registry);
+ * const schemas = new JsonSchemaPlanner(graph, files, resolvers, definitions, registry);
+ */
+export declare class JsonSchemaPlanner {
+    private readonly graph;
+    private readonly files;
+    private readonly resolvers;
+    private readonly definitions;
+    private readonly registry;
+    /**
+     * Creates a planner.
+     *
+     * @param files - Renders the text of the file.
+     * @param resolvers - Links what the file refers to.
+     * @param registry - Receives the file and its `$id`, so refs to the file resolve.
+     */
+    constructor(graph: GraphBuilder, files: FileRenderer, resolvers: ProseResolvers, definitions: DefinitionPlanner, registry: DefinitionRegistry);
+    /**
+     * Adds one schema file.
+     *
+     * @param parent - Folder or skill the file is in.
+     * @param schema - The parsed file.
+     * @returns The node of the file.
+     */
+    plan(parent: NodeRef, file: DocFile, schema: JsonObject): NodeRef;
+}

package/dist/scanner/schema/registry.d.ts

@@ -0,0 +1,61 @@
+import type { NodeRef } from '../../model';
+/**
+ * Writes a JSON pointer in one spelling, so two spellings of one place compare equal.
+ *
+ * @param pointer - A pointer, with or without the `#` in front.
+ * @returns The pointer with every segment decoded. `''` names the root.
+ */
+export declare function normalizePointer(pointer: string): string;
+/** What a `$ref` points at. */
+export interface RefTarget {
+    readonly ref: NodeRef;
+    /** Name of the node, as a type expression shows it. */
+    readonly name: string;
+}
+/**
+ * Finds the nodes that `$ref`s point at, across the JSON Schema files and
+ * OpenAPI documents of one scan.
+ *
+ * Holds a map from `path#pointer` to the node at that place, and a map from
+ * `$id` to file path. Created once per scan by `RepositoryScanner` and shared
+ * by `JsonSchemaPlanner`, `OpenApiPlanner` and `DefinitionPlanner`. The
+ * planners register every file and definition when they add it;
+ * `DefinitionPlanner` resolves refs when the content of the graph is built.
+ * By then every file is read, so a ref can point into a later file.
+ */
+export declare class DefinitionRegistry {
+    /** `path#pointer` to the node at that place. */
+    private readonly places;
+    /** `$id` of a schema file to its path. */
+    private readonly ids;
+    /**
+     * Records the node that shows a place in a file.
+     *
+     * @param path - Path of the file, as the site shows it.
+     * @param pointer - JSON pointer of the place inside the file. `''` is the whole file.
+     */
+    register(path: string, pointer: string, target: RefTarget): void;
+    /**
+     * Records the `$id` of a schema file, so a ref by that id finds the file.
+     *
+     * @param id - The `$id`, an absolute URI.
+     * @param path - Path of the file, as the site shows it.
+     */
+    registerId(id: string, path: string): void;
+    /**
+     * Finds the node a `$ref` points at.
+     *
+     * @param ref - The `$ref` as written: `#/$defs/Cargo`, `cargo.schema.json#/$defs/Cargo`, or the `$id` of a file.
+     * @param fromPath - Path of the file the ref is in. A relative ref starts there.
+     * @returns The node and its name, or `null` when the ref leaves the scan or names nothing the site shows.
+     */
+    resolve(ref: string, fromPath: string): RefTarget | null;
+    /**
+     * Finds the file a URI names.
+     *
+     * @param uri - The part of a ref in front of the `#`.
+     * @param fromPath - Path of the file the ref is in, as the site shows it.
+     * @returns Path of the file: the same file for an empty URI, a registered `$id`, or a relative path. `null` for any other absolute URI.
+     */
+    private pathOf;
+}

package/dist/scanner/skills/classify.d.ts

@@ -0,0 +1,20 @@
+import type { FileKind } from '../../model';
+/** What a file inside a skill directory can be. `source` is code, shown with its symbols. */
+export type SkillFileKind = Exclude<FileKind, 'skill' | 'document'> | 'source';
+/**
+ * Kind of a file in a skill, from where it is and what it is. The first rule that matches wins.
+ *
+ * | Rule | Kind |
+ * |---|---|
+ * | in a `hooks/` directory | `hook` |
+ * | in an `agents/` directory | `agent` |
+ * | in a `schemas/` directory, or named like a schema | `schema` |
+ * | source code | `source` |
+ * | markdown | `reference` |
+ * | JSON | `json` |
+ * | anything else | `asset` |
+ *
+ * @param path - Path relative to the skill directory.
+ * @param isSource - Answers whether a file is source code.
+ */
+export declare function classifySkillFile(path: string, isSource: (path: string) => boolean): SkillFileKind;

package/dist/scanner/skills/layout.d.ts

@@ -0,0 +1,28 @@
+/** File name that makes a directory a skill. */
+export declare const SKILL_FILE = "SKILL.md";
+/** A skill directory and the files that belong to it. */
+export interface SkillLayout {
+    /** Root-relative directory of the `SKILL.md`. `''` for the root itself. */
+    readonly directory: string;
+    /** Root-relative path of the `SKILL.md`. */
+    readonly skillFile: string;
+    /** Every other file of the skill, root-relative. */
+    readonly files: string[];
+}
+/**
+ * Tells whether a file lies in a directory or below it.
+ *
+ * @param file - Root-relative POSIX path.
+ * @param directory - Root-relative POSIX directory. `''` is the root and holds every file.
+ */
+export declare function isInside(file: string, directory: string): boolean;
+/**
+ * Finds the skills in a file list. A skill is a directory with a `SKILL.md`.
+ * Each file belongs to the deepest skill directory around it.
+ *
+ * @param files - Root-relative POSIX paths.
+ * @returns One layout per `SKILL.md`, deepest directory first.
+ */
+export declare function skillLayouts(files: readonly string[]): SkillLayout[];
+/** The files of a list that belong to a skill, `SKILL.md` files included. */
+export declare function skillOwnedFiles(files: readonly string[]): Set<string>;

package/dist/scanner/skills/planner.d.ts

@@ -0,0 +1,46 @@
+import type { NodeRef } from '../../model';
+import type { CodePlanner } from '../code/planner';
+import type { FileRenderer } from '../content';
+import { type Source } from '../files';
+import type { GraphBuilder } from '../graph/builder';
+import type { ProseResolvers } from '../markdown/links';
+import type { SpecPlanner } from '../specs';
+/**
+ * Adds skills to the graph. A skill is its `SKILL.md`. The other files of its
+ * directory become its descendants, each with the kind its place and type
+ * give it. A file that is an OpenAPI document or a JSON Schema goes to the
+ * `SpecPlanner`, a source file to the `CodePlanner`.
+ *
+ * Holds the graph, the file renderer, the code planner, the prose resolvers
+ * and the spec planner. Created and run by `RepositoryScanner` once per scan.
+ *
+ * @example
+ * await new SkillPlanner(graph, files, code, resolvers, specs).plan(sections.skills, input.skills);
+ */
+export declare class SkillPlanner {
+    private readonly graph;
+    private readonly files;
+    private readonly code;
+    private readonly resolvers;
+    private readonly specs;
+    /** Creates a planner. */
+    constructor(graph: GraphBuilder, files: FileRenderer, code: CodePlanner, resolvers: ProseResolvers, specs: SpecPlanner);
+    /**
+     * Adds the skills of every source, sorted by name, each with a unique slug.
+     *
+     * @param section - Node of the skills section, the parent of every skill.
+     */
+    plan(section: NodeRef, sources: readonly Source[]): Promise<void>;
+    /**
+     * Reads the `SKILL.md` of a skill and picks its name: the `name` field of
+     * the frontmatter, else the first `#` heading, else the directory name.
+     */
+    private read;
+    /**
+     * Adds one skill node and a node for each of its files, under folder nodes
+     * that mirror the skill directory.
+     *
+     * @param slugs - Slugs already taken by other skills. Receives the slug of this one.
+     */
+    private planSkill;
+}

package/dist/scanner/specs.d.ts

@@ -0,0 +1,50 @@
+import type { NodeRef } from '../model';
+import type { DocFile } from './docs';
+import type { OpenApiPlanner } from './openapi/planner';
+import { type Reporter } from './reporter';
+import { type JsonObject } from './schema/describe';
+import type { JsonSchemaPlanner } from './schema/planner';
+/**
+ * A **spec** is a JSON or YAML file that describes data or an API in a
+ * standard format: an OpenAPI document or a JSON Schema.
+ */
+export type SpecKind = 'openapi' | 'json-schema';
+/**
+ * Tells what kind of spec a parsed file is.
+ *
+ * @returns `openapi` for a document with an `openapi` version 3 and paths, components or webhooks. `json-schema` for a document whose `$schema` names JSON Schema, or that is named like a schema and uses its keywords. `null` for anything else.
+ */
+export declare function specKind(path: string, document: JsonObject): SpecKind | null;
+/**
+ * Adds the specs among the JSON and YAML files of a scan to the graph.
+ *
+ * Used by `DocPlanner` and `SkillPlanner` for every JSON or YAML file, before
+ * they add the file as plain text. The file is parsed once here, and goes to
+ * the planner of its kind. Created by `RepositoryScanner` for every scan.
+ */
+export declare class SpecPlanner {
+    private readonly openapi;
+    private readonly schemas;
+    private readonly reporter;
+    /**
+     * Keeps the planner of each spec kind.
+     *
+     * @param reporter - Receives files that cannot be read.
+     */
+    constructor(openapi: OpenApiPlanner, schemas: JsonSchemaPlanner, reporter?: Reporter);
+    /** Tells whether a file can be a spec: true for a JSON or YAML file. */
+    handles(path: string): boolean;
+    /**
+     * Reads one file and adds it when it is a spec.
+     *
+     * @param parent - Gives the folder or skill the file is in. Called only for a spec, so a folder with nothing else in it is not added.
+     * @returns The node of the file, or `null` when the file is no spec or cannot be parsed.
+     */
+    plan(file: DocFile, parent: () => NodeRef): Promise<NodeRef | null>;
+    /**
+     * Parses a file.
+     *
+     * @returns The parsed object, or `null` for a file that is too large, holds no object or is not valid.
+     */
+    private read;
+}

package/dist/scanner/sql/catalog.d.ts

@@ -0,0 +1,84 @@
+import type { NodeRef } from '../../model';
+import type { SourceFile } from '../code/planner';
+import type { GraphBuilder } from '../graph/builder';
+import type { CodeHighlighter } from '../highlight';
+import type { ProseResolvers } from '../markdown/links';
+import type { MarkdownRenderer } from '../markdown/renderer';
+import type { ParsedQuery } from './query';
+import { type TableRegistry } from './registry';
+/** One SQL file of a catalog with the entries it holds. */
+export interface CatalogFile {
+    readonly file: SourceFile;
+    /** From `parseQueryFile`. Not empty. */
+    readonly queries: readonly ParsedQuery[];
+}
+/** Where a catalog goes in the tree and what it is called. */
+export interface CatalogPlace {
+    readonly parent: NodeRef;
+    readonly name: string;
+    /** Segment of the route of the catalog, when it is not the name. */
+    readonly slug?: string;
+    /** Path of the directory of the catalog, as the site shows it. */
+    readonly path: string;
+}
+/**
+ * Adds query catalogs to the graph: one `catalog` node per directory, one
+ * `query` node per entry, one `parameter` node per placeholder and one
+ * `field` node per column of the rows an entry returns. A table an entry
+ * names becomes a `reads` or a `writes` edge to that table.
+ *
+ * `DatabasePlanner` calls `add` once per directory that holds SQL files
+ * without tables. Tables and columns are looked up when the content of the
+ * graph is built, so a query can name a table of any file of the scan.
+ * `RepositoryScanner` creates one per scan with the `TableRegistry` it shares
+ * with the `SqlPlanner`; `DatabasePlanner` shows the wiring.
+ */
+export declare class CatalogPlanner {
+    private readonly graph;
+    private readonly markdown;
+    private readonly highlighter;
+    private readonly resolvers;
+    private readonly tables;
+    /**
+     * Creates a planner.
+     *
+     * @param markdown - Renders the notes of entries.
+     * @param highlighter - Highlights the SQL of entries.
+     * @param resolvers - Links what notes refer to.
+     * @param tables - Finds the tables and columns that entries name.
+     */
+    constructor(graph: GraphBuilder, markdown: MarkdownRenderer, highlighter: CodeHighlighter, resolvers: ProseResolvers, tables: TableRegistry);
+    /**
+     * Adds one catalog with its entries.
+     *
+     * @param files - The SQL files of the catalog, in display order.
+     * @returns The node of the catalog.
+     */
+    add(place: CatalogPlace, files: readonly CatalogFile[]): NodeRef;
+    /**
+     * Adds one entry with its placeholders and its result columns.
+     *
+     * @param catalog - Node of the catalog.
+     * @param anchors - Anchors the catalog uses already. The anchor of the entry is added.
+     * @returns The node of the entry.
+     */
+    private addQuery;
+    /**
+     * Finds the table column a column of a statement means.
+     *
+     * @param ref - The column as the statement names it, or `null`.
+     * @param query - The entry the statement is in.
+     * @param path - Display path (`SourceFile.displayPath`) of the file of the entry.
+     * @returns The column of the named table. For a column without a table in front: the column of that name when exactly one table of the entry has it. Else `null`.
+     */
+    private columnOf;
+    /**
+     * Replaces `*` and `t.*` in the result columns of an entry by the columns
+     * of the tables they stand for. That needs the tables at the time the
+     * entry is added, so `DatabasePlanner` adds schema files first.
+     *
+     * @param path - Display path (`SourceFile.displayPath`) of the file of the entry.
+     * @returns The result columns, with every star replaced whose tables the scan has. Any other star stays.
+     */
+    private expand;
+}

package/dist/scanner/sql/cursor.d.ts

@@ -0,0 +1,107 @@
+import type { SqlToken } from './tokens';
+/**
+ * Error for a statement that cannot be read. Thrown by `TokenCursor` and by
+ * the readers of `parse.ts`. `parseSqlSchema` catches it and skips the statement.
+ */
+export declare class SqlSyntaxError extends Error {
+}
+/**
+ * Walks the tokens of one statement. Holds the tokens, the SQL text they come
+ * from and the position of the cursor. The functions of `parse.ts` that read a
+ * statement, a column or a constraint each take a cursor, read what they know
+ * and leave the cursor behind it. `parseSqlSchema` creates one per statement,
+ * and `over` creates one for a part of a statement.
+ */
+export declare class TokenCursor {
+    private readonly tokens;
+    private readonly source;
+    private index;
+    /**
+     * Creates a cursor at the first token.
+     *
+     * @param source - The SQL text the tokens come from, for reading text back as written.
+     */
+    constructor(tokens: readonly SqlToken[], source: string);
+    /**
+     * Tells whether every token is taken.
+     */
+    get done(): boolean;
+    /**
+     * Looks at a token without taking it.
+     *
+     * @param offset - Tokens ahead of the current one.
+     * @returns The token, or `undefined` behind the end.
+     */
+    peek(offset?: number): SqlToken | undefined;
+    /**
+     * Takes the current token.
+     *
+     * @throws {SqlSyntaxError} At the end of the statement.
+     */
+    next(): SqlToken;
+    /**
+     * Tells whether the current token is one of the given keywords.
+     *
+     * @param words - Keywords in capitals.
+     * @param offset - Tokens ahead of the current one.
+     * @returns True for an unquoted word that is one of them, whatever its case.
+     */
+    isWord(words: readonly string[], offset?: number): boolean;
+    /**
+     * Takes the tokens ahead when they are the given keywords in this order.
+     *
+     * @param words - Keywords in capitals.
+     * @returns True when all were there and are taken. False leaves the cursor in place.
+     */
+    accept(...words: string[]): boolean;
+    /**
+     * Tells whether the current token is a given symbol.
+     *
+     * @param symbol - One character.
+     */
+    isSymbol(symbol: string): boolean;
+    /**
+     * Takes the current token when it is a given symbol.
+     *
+     * @param symbol - One character.
+     */
+    acceptSymbol(symbol: string): boolean;
+    /**
+     * Takes a name: an unquoted word or a quoted identifier. A string counts,
+     * because SQLite reads a string as a name where a name has to be.
+     *
+     * @returns The name without quotes.
+     * @throws {SqlSyntaxError} When the current token cannot be a name.
+     */
+    name(): string;
+    /**
+     * Takes a name that may have a schema in front, as in `main.booking`.
+     *
+     * @returns The last part of the name.
+     */
+    qualifiedName(): string;
+    /**
+     * Takes a group in parentheses with everything inside it.
+     *
+     * @returns The tokens between the parentheses.
+     * @throws {SqlSyntaxError} When the current token opens no group, or the group never closes.
+     */
+    group(): SqlToken[];
+    /**
+     * Reads SQL back as written, with runs of whitespace as one space.
+     *
+     * @param to - Last token of the text. Defaults to the token in front of the cursor.
+     */
+    text(from: SqlToken, to?: SqlToken | undefined): string;
+    /**
+     * Creates a cursor for some of the tokens of the same text.
+     */
+    over(tokens: readonly SqlToken[]): TokenCursor;
+}
+/**
+ * Splits tokens at the commas that are not inside parentheses.
+ *
+ * @param tokens - Tokens of a list, without the parentheses around it.
+ * @returns The tokens of each item. An empty item is left out.
+ */
+export declare function splitAtCommas(tokens: readonly SqlToken[]): SqlToken[][];

package/dist/scanner/sql/database.d.ts

@@ -0,0 +1,48 @@
+import type { NodeRef } from '../../model';
+import { type Source } from '../files';
+import type { GraphBuilder } from '../graph/builder';
+import { type Reporter } from '../reporter';
+import type { CatalogPlanner } from './catalog';
+import type { SqlPlanner } from './planner';
+/**
+ * Builds the database section from the SQL files of a directory tree.
+ *
+ * A file that creates a table is a schema and goes to the `SqlPlanner`.
+ * Every other SQL file holds queries and statements. The files of one
+ * directory form a catalog, which goes to the `CatalogPlanner`. The section
+ * starts at the directory the SQL files share, so a reader is not led
+ * through folders that hold nothing else.
+ *
+ * `RepositoryScanner` creates one per scan and calls `planTree` once per
+ * source directory. The `SqlPlanner` and the `CatalogPlanner` share one
+ * `TableRegistry`, so queries can find the tables of schema files.
+ *
+ * @example
+ * const tables = new TableRegistry();
+ * const sql = new SqlPlanner(graph, markdown, highlighter, resolvers, tables, reporter);
+ * const databases = new DatabasePlanner(
+ *   graph,
+ *   sql,
+ *   new CatalogPlanner(graph, markdown, highlighter, resolvers, tables),
+ *   reporter,
+ * );
+ * await databases.planTree(section, source);
+ */
+export declare class DatabasePlanner {
+    private readonly graph;
+    private readonly schemas;
+    private readonly catalogs;
+    private readonly reporter;
+    /**
+     * Creates a planner.
+     *
+     * @param reporter - Receives files that cannot be read.
+     */
+    constructor(graph: GraphBuilder, schemas: SqlPlanner, catalogs: CatalogPlanner, reporter?: Reporter);
+    /**
+     * Adds every SQL file of `source` below `section`.
+     *
+     * @param section - Node of the database section.
+     */
+    planTree(section: NodeRef, source: Source): Promise<void>;
+}