@g3nomaly/analyze 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,87 @@
+/** What a `REFERENCES` clause states. */
+export interface ParsedReference {
+    /** Name of the referenced table. */
+    readonly table: string;
+    /** Referenced columns. Empty when the clause names none, which means the primary key. */
+    readonly columns: readonly string[];
+    /** Action in capitals, or `''`. */
+    readonly onDelete: string;
+    readonly onUpdate: string;
+}
+/** A foreign key of a table, from a column or from a table constraint. */
+export interface ParsedForeignKey extends ParsedReference {
+    /** Name of the constraint, or `''`. */
+    readonly name: string;
+    /** Columns of the table that hold the key. */
+    readonly sourceColumns: readonly string[];
+}
+/** One column of a table as its statement writes it. */
+export interface ParsedColumn {
+    readonly name: string;
+    /** Declared type as written, with single spaces. `''` for a column without one. */
+    readonly type: string;
+    /** True when the column is declared `NOT NULL`. */
+    readonly notNull: boolean;
+    /** Default value as written, or `null`. */
+    readonly defaultValue: string | null;
+    /** Other constraints of the column as written, such as `UNIQUE`, `CHECK (n > 0)` or `COLLATE NOCASE`. */
+    readonly constraints: readonly string[];
+    /** Markdown from the comment behind or above the column. */
+    readonly description: string;
+}
+/** An index of a table, from a `CREATE INDEX` statement. */
+export interface ParsedIndex {
+    readonly name: string;
+    /** Indexed columns or expressions as written. */
+    readonly columns: readonly string[];
+    readonly unique: boolean;
+}
+/** One table of a schema. */
+export interface ParsedTable {
+    readonly name: string;
+    /** 1-based line of the statement. */
+    readonly line: number;
+    /** Markdown from the comment above the statement. */
+    readonly description: string;
+    readonly columns: readonly ParsedColumn[];
+    /** Columns of the primary key, in key order. */
+    readonly primaryKey: readonly string[];
+    readonly foreignKeys: readonly ParsedForeignKey[];
+    /** Table constraints that are no key, as written. */
+    readonly constraints: readonly string[];
+    /** `WITHOUT ROWID`, `STRICT`, `VIRTUAL`, `TEMPORARY`. */
+    readonly options: readonly string[];
+    readonly indexes: readonly ParsedIndex[];
+}
+/** A view or a trigger of a schema. */
+export interface ParsedObject {
+    readonly kind: 'view' | 'trigger';
+    readonly name: string;
+    /** The table a trigger fires on. `''` for a view. */
+    readonly table: string;
+    readonly line: number;
+    readonly description: string;
+    /** The statement as written, without the closing semicolon. */
+    readonly sql: string;
+}
+/** What a schema file declares, from `parseSqlSchema`. */
+export interface ParsedSchema {
+    /** Markdown from the comments that open the file. */
+    readonly intro: string;
+    readonly tables: readonly ParsedTable[];
+    readonly objects: readonly ParsedObject[];
+}
+/**
+ * Reads the tables, indexes, views and triggers of a SQLite schema file.
+ * Statements of any other kind, and statements that cannot be read, are
+ * skipped. The SQL is read as text and never run.
+ *
+ * A comment directly above a statement describes its table, view or trigger.
+ * A comment behind a column on the same line, or directly above it, describes
+ * the column. The comments that open the file, apart from the first
+ * statement, are the introduction.
+ *
+ * @param source - Text of the file.
+ * @returns What the file declares, in file order.
+ */
+export declare function parseSqlSchema(source: string): ParsedSchema;

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

@@ -0,0 +1,65 @@
+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 Reporter } from '../reporter';
+import { type ParsedSchema } from './parse';
+import type { TableRegistry } from './registry';
+/**
+ * Adds SQL schema files to the graph: one `database` node per file, one
+ * `table` node per table and one `field` node per column. A foreign key
+ * becomes a `references` edge from its table to the table it points at.
+ *
+ * `DatabasePlanner` calls `add` for every schema file of the repository, and
+ * `CodePlanner` calls `plan` for a `.sql` file that belongs to a skill.
+ * `RepositoryScanner` creates one per scan with the `TableRegistry` it shares
+ * with the `CatalogPlanner`; `DatabasePlanner` shows the wiring.
+ */
+export declare class SqlPlanner {
+    private readonly graph;
+    private readonly markdown;
+    private readonly highlighter;
+    private readonly resolvers;
+    private readonly tables;
+    private readonly reporter;
+    /**
+     * Creates a planner.
+     *
+     * @param markdown - Renders comments.
+     * @param highlighter - Highlights the statements of views and triggers.
+     * @param resolvers - Links what comments refer to.
+     * @param tables - Receives every table with its columns, and finds the targets of foreign keys.
+     * @param reporter - Receives files that cannot be read.
+     */
+    constructor(graph: GraphBuilder, markdown: MarkdownRenderer, highlighter: CodeHighlighter, resolvers: ProseResolvers, tables: TableRegistry, reporter?: Reporter);
+    /**
+     * Tells whether a file is SQL: its extension is `.sql`, in any case.
+     */
+    handles(path: string): boolean;
+    /**
+     * Reads one SQL file and adds its nodes when it creates a table.
+     *
+     * @param parent - Gives the folder or skill the file is in. Called only when the file creates a table, so a folder with nothing else in it is not added.
+     * @returns The node of the file, or `null` when it creates no table or cannot be read.
+     */
+    plan(file: SourceFile, parent: () => NodeRef): Promise<NodeRef | null>;
+    /**
+     * Adds the nodes of one schema file.
+     *
+     * @param schema - What the file declares, from `parseSqlSchema`.
+     * @param parent - The folder or skill the file is in.
+     * @returns The node of the file.
+     */
+    add(file: SourceFile, schema: ParsedSchema, parent: NodeRef): NodeRef;
+    /**
+     * Resolves a foreign key against the tables of the scan, and records the
+     * edge to its target.
+     *
+     * @param from - Node of the table that holds the key.
+     * @param path - Display path (`SourceFile.displayPath`) of the file the key is in.
+     * @returns The key with its target, and with the primary key of the target as its columns when the statement names none.
+     */
+    private foreignKey;
+}

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

@@ -0,0 +1,60 @@
+import type { QueryEffect, QueryTable } from '../../model';
+/** A column a statement names. */
+export interface ParsedColumnRef {
+    /** Name of the table in front of the column, with an alias replaced by its table. `null` for a column without one. */
+    readonly table: string | null;
+    /** Name of the column. `*` for every column. */
+    readonly column: string;
+}
+/** One placeholder of a statement. */
+export interface ParsedParameter {
+    /** The placeholder as written: `:map_id`, `@id`, `$id`, `?2`. A plain `?` gets the number SQLite gives it: `?1`. */
+    readonly name: string;
+    /** The column the placeholder is compared with or stored in, when the statement shows one. */
+    readonly column: ParsedColumnRef | null;
+    /** True for the row count of a `LIMIT` or an `OFFSET`. */
+    readonly count: boolean;
+}
+/** One column of the rows a statement returns. */
+export interface ParsedResultColumn {
+    /** Name of the column in the result: its alias, else the column it selects, else the expression as written. `*` and `t.*` stand for every column of a table. */
+    readonly name: string;
+    /** The expression behind an alias, as written. `''` for a column of a table. */
+    readonly expression: string;
+    /** The column of a table it selects. `null` for an expression. */
+    readonly column: ParsedColumnRef | null;
+}
+/** A table a statement names, and what it does with it. */
+export type ParsedQueryTable = Pick<QueryTable, 'name' | 'access'>;
+/** One entry of a query catalog, as its file writes it. */
+export interface ParsedQuery {
+    /** Name from a `-- name:` line above the SQL. `null` when the file has no such line, so the file names the entry. */
+    readonly name: string | null;
+    /** 1-based line the SQL starts on. */
+    readonly line: number;
+    readonly effect: QueryEffect;
+    /** The keywords that open the statement, in capitals: `SELECT`, `INSERT`, `BEGIN IMMEDIATE`. */
+    readonly verb: string;
+    /** Markdown from the comments above the SQL. */
+    readonly note: string;
+    /** The SQL as written, without the closing semicolon. */
+    readonly sql: string;
+    /** In the order SQLite numbers them, each once. */
+    readonly parameters: readonly ParsedParameter[];
+    /** In the order they first appear, each once per access. */
+    readonly tables: readonly ParsedQueryTable[];
+    /** In result order. Empty for a statement that returns no rows. */
+    readonly columns: readonly ParsedResultColumn[];
+}
+/**
+ * Reads a SQL file of a query catalog: a file of queries and statements that
+ * creates no table. The SQL is read as text and never run.
+ *
+ * A file is one entry, named by the file. A file that names its statements
+ * with comment lines such as `-- name: list_bookings` is one entry per name.
+ * The comments above the SQL of an entry are its note.
+ *
+ * @param source - Text of the file.
+ * @returns The entries in file order. Empty for a file without a statement.
+ */
+export declare function parseQueryFile(source: string): ParsedQuery[];

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

@@ -0,0 +1,49 @@
+import type { NodeRef } from '../../model';
+/** A column of a table as the registry knows it. */
+export interface ColumnEntry {
+    readonly ref: NodeRef;
+    /** Name of the column, as its table writes it. */
+    readonly name: string;
+    /** Declared type, or `''`. */
+    readonly type: string;
+}
+/** A table as the registry knows it. */
+export interface TableEntry {
+    readonly ref: NodeRef;
+    /** Name of the table, as its statement writes it. */
+    readonly name: string;
+    /** Display path (`SourceFile.displayPath`) of the file that creates the table. */
+    readonly path: string;
+    /** Columns of its primary key, in key order. */
+    readonly primaryKey: readonly string[];
+    /** Its columns, in table order. */
+    readonly columns: readonly ColumnEntry[];
+}
+/**
+ * Finds a column of a table by name. Capitals do not matter, as in SQLite.
+ *
+ * @returns The column, or `undefined` when the table has none of that name.
+ */
+export declare function columnOf(table: TableEntry, name: string): ColumnEntry | undefined;
+/**
+ * Finds tables by name across the SQL files of one scan.
+ *
+ * `SqlPlanner` registers every table when it adds it, and looks tables up
+ * when the content of the graph is built. By then every file is read, so a
+ * foreign key can point at a table of a later file. `CatalogPlanner` looks
+ * up the tables and columns that queries name. Holds the tables by their
+ * lowercase name. `RepositoryScanner` creates one per scan and hands it to
+ * both planners.
+ */
+export declare class TableRegistry {
+    private readonly byName;
+    /** Records a table under its name. Capitals of the name do not matter, as in SQLite. */
+    register(entry: TableEntry): void;
+    /**
+     * Finds the table a name in a SQL file means.
+     *
+     * @param path - Display path of the file the name is in, as in `TableEntry.path`.
+     * @returns The table of that name in the same file, else the only table of that name in the scan, else `null`.
+     */
+    find(name: string, path: string): TableEntry | null;
+}

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

@@ -0,0 +1,9 @@
+import type { SourceFile } from '../code/planner';
+import type { Reporter } from '../reporter';
+/**
+ * Reads the text of a SQL file.
+ *
+ * @param reporter - Receives a warning when the file cannot be read.
+ * @returns The text, or `null` for a file that is too large or cannot be read.
+ */
+export declare function readSqlFile(file: SourceFile, reporter: Reporter): Promise<string | null>;

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

@@ -0,0 +1,36 @@
+import type { SqlComment, SqlToken } from './tokens';
+/**
+ * Turns comments into markdown.
+ *
+ * @param comments - Comments in file order.
+ * @returns Their text without ruler lines and shared indentation. Comments that are apart become paragraphs.
+ */
+export declare function markdownOf(comments: readonly SqlComment[]): string;
+/**
+ * Finds the comments that describe what starts on a line: the comments on
+ * lines of their own directly above it, without a blank line between.
+ *
+ * @param comments - Every comment of the file, in file order.
+ * @param line - 1-based line the described statement or column starts on.
+ * @returns The comments, in file order.
+ */
+export declare function commentsAbove(comments: readonly SqlComment[], line: number): SqlComment[];
+/** One statement of a file, with its tokens. */
+export interface Statement {
+    readonly tokens: readonly SqlToken[];
+}
+/**
+ * Splits the tokens of a file into statements at the semicolons. The
+ * semicolons inside the body of a trigger do not end its statement.
+ *
+ * @param tokens - Every token of the file.
+ * @returns The statements, each without its closing semicolon.
+ */
+export declare function statementsOf(tokens: readonly SqlToken[]): Statement[];
+/**
+ * Reads a statement back as written.
+ *
+ * @param source - Text of the whole file.
+ * @returns The statement with its line breaks, without the closing semicolon.
+ */
+export declare function sqlOf(source: string, first: SqlToken, last: SqlToken): string;

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

@@ -0,0 +1,38 @@
+/** What a token of a SQL text is. A `name` is a quoted identifier. */
+export type SqlTokenKind = 'word' | 'name' | 'string' | 'number' | 'symbol';
+/** One token of a SQL text. Comments are no tokens. */
+export interface SqlToken {
+    readonly kind: SqlTokenKind;
+    /** The token without quotes and escapes. For a word, a number or a symbol: the token as written. */
+    readonly value: string;
+    /** 1-based line the token starts on. */
+    readonly line: number;
+    /** 1-based line the token ends on. */
+    readonly endLine: number;
+    /** Offset of the first character in the text. */
+    readonly start: number;
+    /** Offset behind the last character. */
+    readonly end: number;
+}
+/** One comment of a SQL text. */
+export interface SqlComment {
+    /** The comment without its markers, one entry per line. */
+    readonly lines: readonly string[];
+    /** 1-based line the comment starts on. */
+    readonly line: number;
+    /** 1-based line the comment ends on. */
+    readonly endLine: number;
+    /** True when no token is in front of the comment on its line. */
+    readonly alone: boolean;
+}
+/** The tokens and the comments of a SQL text, from `tokenizeSql`. */
+export interface SqlTokens {
+    readonly tokens: readonly SqlToken[];
+    readonly comments: readonly SqlComment[];
+}
+/**
+ * Splits a SQL text into tokens and comments.
+ *
+ * @returns The tokens in text order, and the comments apart from them. Text that is no SQL becomes symbol tokens, so the function never fails.
+ */
+export declare function tokenizeSql(source: string): SqlTokens;

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

@@ -0,0 +1,40 @@
+/** Folder of a phase that holds its task files. */
+export declare const TASKS_DIR = "tasks";
+/** Folder of a plan that holds its decision files. */
+export declare const DECISIONS_DIR = "decisions";
+/** File at the root of the tree that holds its terms. */
+export declare const VOCABULARY_FILE = "vocabulary.md";
+/** A phase of the tree as its files lay it out. */
+export interface PhaseFiles {
+    readonly name: string;
+    /** Tree-relative path of `<plan>/<phase>/<phase>.md`. */
+    readonly file: string;
+    /** Tree-relative paths of the task files, sorted by name. */
+    readonly tasks: readonly string[];
+}
+/** A plan of the tree as its files lay it out. */
+export interface PlanFiles {
+    readonly name: string;
+    /** Tree-relative path of `<plan>/<plan>.md`. */
+    readonly file: string;
+    /** Sorted by folder name, which is the order task-manager queues them in. */
+    readonly phases: readonly PhaseFiles[];
+    /** Tree-relative paths of the decision files, sorted by name. */
+    readonly decisions: readonly string[];
+}
+/** The task tree as its files lay it out. */
+export interface TreeFiles {
+    readonly plans: readonly PlanFiles[];
+    /** Tree-relative path of the vocabulary, or `null` when the tree has none. */
+    readonly vocabulary: string | null;
+}
+/**
+ * Sorts the files of a task tree into plans, phases, tasks and decisions by
+ * where they are: `<plan>/<plan>.md`, `<plan>/<phase>/<phase>.md`,
+ * `<plan>/<phase>/tasks/<id>.md` and `<plan>/decisions/<id>.md`. Index files
+ * and any other file are left out, since task-manager derives them.
+ *
+ * @param files - Paths relative to the root of the tree, in POSIX form.
+ * @returns The plans in folder order, each with its phases and decisions.
+ */
+export declare function layoutTree(files: readonly string[]): TreeFiles;

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

@@ -0,0 +1,75 @@
+import type { NodeRef } from '../../model';
+import type { FileRenderer } from '../content';
+import type { Source } from '../files';
+import type { GlossaryPlanner } from '../glossary/planner';
+import type { GraphBuilder } from '../graph/builder';
+import type { ProseResolvers } from '../markdown/links';
+import type { MarkdownRenderer } from '../markdown/renderer';
+import type { Reporter } from '../reporter';
+/** The task tree of one scan: the files below its directory, with paths relative to the scanned root. */
+export interface TaskTreeSource extends Source {
+    /** Root-relative POSIX path of the tree, such as `docs/task-manager`. */
+    readonly dir: string;
+}
+/**
+ * Adds the tasks section to the graph from a task-manager tree: one `plan`
+ * page per plan, one `phase` page per phase, one `task` entry per task file,
+ * a `decisions` page per plan with decision files, and the `vocabulary.md`
+ * of the tree as a glossary. Created by `RepositoryScanner` for every scan.
+ *
+ * What a plan, a phase or a task links to or names in inline code becomes a
+ * `names` edge, and every `depends_on` a `depends` edge. A file whose
+ * frontmatter fails its schema is reported and shown as a plain document.
+ *
+ * Holds the graph, the file renderer, the markdown renderer, the prose
+ * resolvers, the `GlossaryPlanner` for the vocabulary and the reporter for
+ * warnings.
+ *
+ * @example
+ * await new TaskPlanner(graph, files, markdown, resolvers, glossaries, reporter).plan(sections.tasks, input.tasks);
+ */
+export declare class TaskPlanner {
+    private readonly graph;
+    private readonly files;
+    private readonly markdown;
+    private readonly resolvers;
+    private readonly glossaries;
+    private readonly reporter;
+    /**
+     * Creates a planner.
+     *
+     * @param reporter - Receives a warning for every file that fails its schema and every `depends_on` that names nothing.
+     */
+    constructor(graph: GraphBuilder, files: FileRenderer, markdown: MarkdownRenderer, resolvers: ProseResolvers, glossaries: GlossaryPlanner, reporter: Reporter);
+    /**
+     * Adds every plan of the trees, with its phases, tasks and decisions.
+     *
+     * @param section - Node of the tasks section.
+     * @param trees - The task trees of the scan. Usually one, or none when the repository keeps no tasks.
+     */
+    plan(section: NodeRef, trees: readonly TaskTreeSource[]): Promise<void>;
+    /** Adds one plan with its phases and decisions. */
+    private planPlan;
+    /** Adds one phase with its tasks. */
+    private planPhase;
+    /** Adds the decision log of a plan: one `decisions` page for its folder and one `decision` entry per file. */
+    private planDecisions;
+    /**
+     * Renders the page of a plan or a phase whose frontmatter passed its schema.
+     *
+     * @returns The content of the node: the rendered file, its title and summary, and where it stands.
+     */
+    private renderTracked;
+    /** Adds a tree file whose frontmatter failed its schema as a plain document. */
+    private planDocument;
+    /**
+     * Checks the frontmatter of a file against its schema, and reports the file when it fails.
+     *
+     * @returns The parsed frontmatter, or `null` when it failed.
+     */
+    private parse;
+    /** Reads a file of the tree and splits off its frontmatter. */
+    private read;
+    /** The paths of a tree file as the planners of the docs section take them. */
+    private docFile;
+}

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

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+/** Frontmatter of a plan file, `<plan>/<plan>.md`. Fields the site does not show are let through unread. */
+export declare const PlanFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    priority: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    summary: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        "in-progress": "in-progress";
+        "in-review": "in-review";
+        open: "open";
+    }>;
+}, z.core.$strip>;
+/** Parsed frontmatter of a plan file. */
+export type PlanFrontmatter = z.infer<typeof PlanFrontmatterSchema>;
+/** Frontmatter of a phase file, `<plan>/<phase>/<phase>.md`. task-manager spells the parallel flag `parrallel`. */
+export declare const PhaseFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    priority: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    summary: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        "in-progress": "in-progress";
+        "in-review": "in-review";
+        open: "open";
+    }>;
+    parrallel: z.ZodOptional<z.ZodBoolean>;
+    parallel: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Parsed frontmatter of a phase file. */
+export type PhaseFrontmatter = z.infer<typeof PhaseFrontmatterSchema>;
+/** Frontmatter of a task file, `<plan>/<phase>/tasks/<id>.md`. */
+export declare const TaskFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    package: z.ZodString;
+    priority: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    summary: z.ZodString;
+    complexity: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        "in-progress": "in-progress";
+        "in-review": "in-review";
+        open: "open";
+    }>;
+}, z.core.$strip>;
+/** Parsed frontmatter of a task file. */
+export type TaskFrontmatter = z.infer<typeof TaskFrontmatterSchema>;
+/** Frontmatter of a decision file in a plan's `decisions/` folder. */
+export declare const DecisionFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodString;
+    date: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    supersedes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Parsed frontmatter of a decision file. */
+export type DecisionFrontmatter = z.infer<typeof DecisionFrontmatterSchema>;
+/**
+ * Describes why a frontmatter block failed its schema, for a warning.
+ *
+ * @param error - The error of a failed `safeParse`.
+ * @returns The issues joined, such as `status: Invalid option; summary: Required`.
+ */
+export declare function describeIssues(error: z.ZodError): string;

package/dist/scanner/text.d.ts

@@ -0,0 +1,14 @@
+/** Turns a text into a lowercase, hyphen-separated identifier that is safe in a URL path segment, or `untitled`. */
+export declare function slugify(value: string): string;
+/** Returns `base`, or `base-2`, `base-3`… when `base` is already in `taken`, and adds the result to `taken`. */
+export declare function uniqueId(base: string, taken: Set<string>, separator?: string): string;
+/** Removes the indentation shared by every non-blank line. */
+export declare function dedent(text: string): string;
+/** Dedents and drops leading and trailing blank lines. */
+export declare function trimBlock(text: string): string;
+/** Escapes `&`, `<`, `>` and `"` for HTML text and attribute values. */
+export declare function escapeHtml(value: string): string;
+/** Converts a name in any case to camelCase, such as `user_id` to `userId`. */
+export declare function toCamelCase(name: string): string;
+/** Converts a name in any case to snake_case, such as `userId` to `user_id`. */
+export declare function toSnakeCase(name: string): string;