@pristine-ts/mysql-cli 2.0.16

package/dist/types/commands/mysql-migrate-create.command-options.d.ts

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+/**
+ * Flags for `pristine mysql:create --name <name> [--config <keyname>]`.
+ *
+ * `name` is the human-readable description (e.g. `add-products-table`). The scaffold
+ * slugifies it, prepends the next sequential number, and writes the `.ts` file. It is
+ * required; when it isn't passed and the terminal is interactive, the CLI asks for it.
+ */
+export declare class MysqlMigrateCreateCommandOptions {
+    name: string;
+    config?: string;
+}

package/dist/types/commands/mysql-migrate-create.command.d.ts

@@ -0,0 +1,32 @@
+import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { CommandInterface, CliOutput } from "@pristine-ts/cli";
+import { MysqlMigrationScaffoldManager } from "../managers/mysql-migration-scaffold.manager";
+import { MysqlMigrateCreateCommandOptions } from "./mysql-migrate-create.command-options";
+/**
+ * `pristine mysql:create --name <name> [--config <keyname>]`
+ *
+ * Scaffolds a new `.sql-migrations.ts` file under the configured scaffold path
+ * (`pristine.mysql-cli.scaffold.path`, default `src/sql-migrations`). When the
+ * config key `pristine.mysql-cli.scaffold.barrelPath` is set, splices the new
+ * import and class reference into that file between the marker comments
+ * `<pristine:migration-imports:start/end>` and `<pristine:migration-services:start/end>`.
+ *
+ * Numbering is sequential: the scaffold scans the target directory for files
+ * matching `<digits>-<slug>.sql-migrations.ts`, picks `max + 1`, pads to the
+ * existing width (default 2). If you cross 99, do a one-time rename of the
+ * existing files to 3-digit width and the scaffold respects it going forward.
+ */
+export declare class MysqlMigrateCreateCommand implements CommandInterface<MysqlMigrateCreateCommandOptions> {
+    private readonly scaffoldPath;
+    private readonly scaffoldBarrelPath;
+    private readonly scaffoldManager;
+    private readonly cliOutput;
+    private readonly logHandler;
+    optionsType: typeof MysqlMigrateCreateCommandOptions;
+    name: string;
+    description: string;
+    constructor(scaffoldPath: string, scaffoldBarrelPath: string, scaffoldManager: MysqlMigrationScaffoldManager, cliOutput: CliOutput, logHandler: LogHandlerInterface);
+    run(args: MysqlMigrateCreateCommandOptions): Promise<ExitCode | number>;
+    private printManualInstructions;
+}

package/dist/types/commands/mysql-migrate-status.command-options.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+/**
+ * Flags for `pristine mysql:status [--config <keyname>]`. Status is informational
+ * and always exits 0 — for a CI gate that fails on drift, use `mysql:verify`.
+ */
+export declare class MysqlMigrateStatusCommandOptions {
+    config?: string;
+}

package/dist/types/commands/mysql-migrate-status.command.d.ts

@@ -0,0 +1,25 @@
+import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { CommandInterface, CliOutput } from "@pristine-ts/cli";
+import { MysqlMigrationManager } from "../managers/mysql-migration.manager";
+import { MysqlMigrateStatusCommandOptions } from "./mysql-migrate-status.command-options";
+/**
+ * `pristine mysql:status [--config <keyname>]`
+ *
+ * Prints the disk-vs-database diff. Reports each migration as Pending, Applied,
+ * Modified, or Orphaned. Informational only — always exits 0. Use `mysql:verify`
+ * to fail on drift.
+ */
+export declare class MysqlMigrateStatusCommand implements CommandInterface<MysqlMigrateStatusCommandOptions> {
+    private readonly migrationManager;
+    private readonly cliOutput;
+    private readonly logHandler;
+    optionsType: typeof MysqlMigrateStatusCommandOptions;
+    name: string;
+    description: string;
+    private static readonly DefaultConfigKeyname;
+    constructor(migrationManager: MysqlMigrationManager, cliOutput: CliOutput, logHandler: LogHandlerInterface);
+    run(args: MysqlMigrateStatusCommandOptions): Promise<ExitCode | number>;
+    private formatState;
+    private formatSuffix;
+}

package/dist/types/commands/mysql-migrate-verify.command-options.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+/**
+ * Flags for `pristine mysql:verify [--config <keyname>]`. Verify exits non-zero
+ * when any Modified or Orphaned entries are detected; designed for CI gates.
+ */
+export declare class MysqlMigrateVerifyCommandOptions {
+    config?: string;
+}

package/dist/types/commands/mysql-migrate-verify.command.d.ts

@@ -0,0 +1,23 @@
+import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { CommandInterface, CliOutput } from "@pristine-ts/cli";
+import { MysqlMigrationManager } from "../managers/mysql-migration.manager";
+import { MysqlMigrateVerifyCommandOptions } from "./mysql-migrate-verify.command-options";
+/**
+ * `pristine mysql:verify [--config <keyname>]`
+ *
+ * Same scan as `mysql:status`, but exits non-zero if any Modified or Orphaned
+ * entries exist. Designed for CI gates: a clean exit means the database and the
+ * registered migrations are in agreement.
+ */
+export declare class MysqlMigrateVerifyCommand implements CommandInterface<MysqlMigrateVerifyCommandOptions> {
+    private readonly migrationManager;
+    private readonly cliOutput;
+    private readonly logHandler;
+    optionsType: typeof MysqlMigrateVerifyCommandOptions;
+    name: string;
+    description: string;
+    private static readonly DefaultConfigKeyname;
+    constructor(migrationManager: MysqlMigrationManager, cliOutput: CliOutput, logHandler: LogHandlerInterface);
+    run(args: MysqlMigrateVerifyCommandOptions): Promise<ExitCode | number>;
+}

package/dist/types/commands/mysql-migrate.command-options.d.ts

@@ -0,0 +1,14 @@
+import "reflect-metadata";
+/**
+ * Flags for `pristine mysql:migrate [--config <keyname>] [--dry-run] [--force]`.
+ *
+ * `--config` picks the `MysqlConfig.uniqueKeyname` to target. Defaults to
+ * `__default__`. `--dry-run` prints the plan without writing anything. `--force`
+ * overrides the refusal-to-proceed when drift (Modified / Orphaned entries) is
+ * detected — used sparingly, on environments you're comfortable diverging.
+ */
+export declare class MysqlMigrateCommandOptions {
+    config?: string;
+    "dry-run"?: boolean;
+    force?: boolean;
+}

package/dist/types/commands/mysql-migrate.command.d.ts

@@ -0,0 +1,23 @@
+import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { CommandInterface, CliOutput } from "@pristine-ts/cli";
+import { MysqlMigrationManager } from "../managers/mysql-migration.manager";
+import { MysqlMigrateCommandOptions } from "./mysql-migrate.command-options";
+/**
+ * `pristine mysql:migrate [--config <keyname>] [--dry-run] [--force]`
+ *
+ * Applies every Pending migration against the targeted database. Halts on the first
+ * failure. Refuses to proceed when drift (Modified / Orphaned entries) exists unless
+ * `--force` is given.
+ */
+export declare class MysqlMigrateCommand implements CommandInterface<MysqlMigrateCommandOptions> {
+    private readonly migrationManager;
+    private readonly cliOutput;
+    private readonly logHandler;
+    optionsType: typeof MysqlMigrateCommandOptions;
+    name: string;
+    description: string;
+    private static readonly DefaultConfigKeyname;
+    constructor(migrationManager: MysqlMigrationManager, cliOutput: CliOutput, logHandler: LogHandlerInterface);
+    run(args: MysqlMigrateCommandOptions): Promise<ExitCode | number>;
+}

package/dist/types/enums/enums.d.ts

@@ -0,0 +1 @@
+export * from "./migration-state.enum";

package/dist/types/enums/migration-state.enum.d.ts

@@ -0,0 +1,23 @@
+/**
+ * State of a single migration as observed by `MysqlMigrationManager.status` /
+ * `verify`. Computed from the union of registered migrations (DI) and applied
+ * records (the `pristine_migrations` table).
+ */
+export declare enum MigrationStateEnum {
+    /** Registered in DI, not in the database. Will be applied next `migrate` run. */
+    Pending = "pending",
+    /** Registered in DI, in the database, checksums match. Nothing to do. */
+    Applied = "applied",
+    /**
+     * Registered in DI, in the database, checksums differ. The migration's `up()` was
+     * edited after it was applied. Verify fails; apply refuses to proceed (unless
+     * `--force`).
+     */
+    Modified = "modified",
+    /**
+     * In the database, not registered in DI. The class was deleted from the codebase,
+     * or the CLI is targeting the wrong config. Verify fails; apply refuses to proceed
+     * (unless `--force`).
+     */
+    Orphaned = "orphaned"
+}

package/dist/types/errors/errors.d.ts

@@ -0,0 +1,5 @@
+export * from "./migration-checksum-mismatch.error";
+export * from "./migration-duplicate-name.error";
+export * from "./migration-execution.error";
+export * from "./migration-invalid-name.error";
+export * from "./migration-orphaned-record.error";

package/dist/types/errors/migration-checksum-mismatch.error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Thrown by `verify` (and by `apply` without `--force`) when a migration that's
+ * already applied has had its `up()` body edited since. Indicates someone changed
+ * a migration after it ran somewhere — the new SQL was never applied to that
+ * database. The fix is either to revert the change or to write a new migration
+ * that produces the desired state.
+ */
+export declare class MigrationChecksumMismatchError extends Error {
+    readonly migrationName: string;
+    readonly configUniqueKeyname: string;
+    readonly diskChecksum: string;
+    readonly appliedChecksum: string;
+    constructor(migrationName: string, configUniqueKeyname: string, diskChecksum: string, appliedChecksum: string);
+}

package/dist/types/errors/migration-duplicate-name.error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Thrown when two registered migrations share the same `name` after filtering by
+ * `configUniqueKeynames` for the targeted config. Names must be globally unique per
+ * config because the database stores them in a `UNIQUE` column. The usual cause is
+ * a copy-paste mistake at scaffold time.
+ */
+export declare class MigrationDuplicateNameError extends Error {
+    readonly migrationName: string;
+    readonly configUniqueKeyname: string;
+    constructor(migrationName: string, configUniqueKeyname: string);
+}

package/dist/types/errors/migration-execution.error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Thrown when mysql2 raises an error while executing a migration's SQL. Carries the
+ * failing migration name and wraps the underlying error for context. The `apply`
+ * orchestrator catches this, halts further migrations, and reports it as the
+ * `failedMigration` entry on the result.
+ */
+export declare class MigrationExecutionError extends Error {
+    readonly migrationName: string;
+    readonly configUniqueKeyname: string;
+    readonly cause: Error;
+    constructor(migrationName: string, configUniqueKeyname: string, cause: Error);
+}

package/dist/types/errors/migration-invalid-name.error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Thrown when a registered migration's `name` doesn't satisfy the
+ * `<NN>-<kebab-slug>` regex (`/^\d+-[a-z0-9-]+$/`). Indicates a hand-edited or
+ * misnamed migration class. The fix is to rename to the convention and update the
+ * `name` field.
+ */
+export declare class MigrationInvalidNameError extends Error {
+    readonly migrationName: string;
+    constructor(migrationName: string);
+}

package/dist/types/errors/migration-orphaned-record.error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Thrown by `verify` (and by `apply` without `--force`) when the bookkeeping table
+ * holds a record for a migration that no longer exists in the registered DI graph.
+ * Indicates a deleted migration class, a renamed `name` field, or running against
+ * the wrong config. The fix is to restore the class, fix the name, or run against
+ * the correct config.
+ */
+export declare class MigrationOrphanedRecordError extends Error {
+    readonly migrationName: string;
+    readonly configUniqueKeyname: string;
+    constructor(migrationName: string, configUniqueKeyname: string);
+}

package/dist/types/interfaces/interfaces.d.ts

@@ -0,0 +1 @@
+export * from "./mysql-migration.interface";

package/dist/types/interfaces/mysql-migration.interface.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Contract every MySQL migration class implements. Implementations are discovered by
+ * the MysqlMigrationManager via the tsyringe DI container — register each class with
+ * `@tag("MysqlMigrationInterface") @injectable()` and import it (directly or via a
+ * MigrationsModule) into the AppModule's service graph.
+ *
+ * Migrations are forward-only by design. There is no `down()`. Roll forward by writing
+ * a new migration.
+ */
+export interface MysqlMigrationInterface {
+    /**
+     * Unique, sortable identifier. Convention: `<NN>-<kebab-slug>` matching the filename
+     * minus `.sql-migrations.ts`. Lexicographic sort across `name` defines the apply
+     * order. Stored verbatim in pristine_migrations.filename.
+     *
+     * Use the convention. Manual identifiers break apply ordering and confuse the
+     * scaffold command. `pristine mysql:create` produces compliant names automatically.
+     */
+    readonly name: string;
+    /**
+     * Which database configs this migration applies to. Each entry is a
+     * `MysqlConfig.uniqueKeyname`.
+     *
+     * Leave undefined to apply to every registered config; set to an explicit list to
+     * scope this migration to one or more specific databases — useful for multi-DB apps
+     * where, say, a schema change only lands in the analytics DB.
+     *
+     * The CLI's `--config <keyname>` flag picks the database being targeted in this
+     * invocation; a migration is selected for that invocation iff
+     * `configUniqueKeynames === undefined || configUniqueKeynames.includes(targetConfig)`.
+     */
+    readonly configUniqueKeynames?: string[];
+    /**
+     * Returns the SQL to execute. The string may contain multiple statements separated
+     * by `;`; the runner connection has `multipleStatements: true`. Async so migrations
+     * can pull dynamic content — but the returned SQL MUST be deterministic across runs,
+     * otherwise checksum-based drift detection will generate false positives.
+     */
+    up(): Promise<string> | string;
+}

package/dist/types/managers/managers.d.ts

@@ -0,0 +1,5 @@
+export * from "./mysql-migration-checksum.manager";
+export * from "./mysql-migration-record.manager";
+export * from "./mysql-migration-runner.manager";
+export * from "./mysql-migration-scaffold.manager";
+export * from "./mysql-migration.manager";

package/dist/types/managers/mysql-migration-checksum.manager.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Computes the stable sha256 hex digest of a migration's SQL string. Used both at
+ * apply time (to record what was applied) and at status/verify time (to detect
+ * drift). Canonicalization strips trivial editor noise — trailing whitespace per
+ * line, CRLF endings, leading/trailing whitespace — so identical SQL with different
+ * line-ending or final-newline conventions hashes the same.
+ *
+ * Whitespace *between* tokens is preserved: changing `SELECT  *` to `SELECT *`
+ * does change the checksum. That's deliberate — anything beyond formatting noise
+ * is a real edit, and the user should know.
+ */
+export declare class MysqlMigrationChecksumManager {
+    compute(sql: string): string;
+    private canonicalize;
+}

package/dist/types/managers/mysql-migration-record.manager.d.ts

@@ -0,0 +1,22 @@
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { MysqlClientInterface } from "@pristine-ts/mysql";
+import { MigrationRecord } from "../models/migration-record.model";
+/**
+ * Owns the `pristine_migrations` bookkeeping table — creates it on demand, reads
+ * the applied rows back, and inserts a new row when a migration finishes.
+ *
+ * Uses the regular `MysqlClient` pool (no `multipleStatements` needed for any of
+ * these queries — they're single statements with parameter placeholders).
+ */
+export declare class MysqlMigrationRecordManager {
+    private readonly mysqlClient;
+    private readonly logHandler;
+    constructor(mysqlClient: MysqlClientInterface, logHandler: LogHandlerInterface);
+    ensureTable(configUniqueKeyname: string, tableName: string): Promise<void>;
+    listApplied(configUniqueKeyname: string, tableName: string): Promise<MigrationRecord[]>;
+    recordApplied(configUniqueKeyname: string, tableName: string, record: {
+        filename: string;
+        checksum: string;
+        executionTimeMs: number;
+    }): Promise<void>;
+}

package/dist/types/managers/mysql-migration-runner.manager.d.ts

@@ -0,0 +1,16 @@
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { MysqlConfigProviderInterface } from "@pristine-ts/mysql";
+/**
+ * Executes a single migration's SQL string against a target database. Opens a
+ * one-shot mysql2 connection with `multipleStatements: true` for the call and
+ * closes it in `finally` — does NOT touch the cached `MysqlClient` pool because
+ * flipping `multipleStatements` on the pool would leak to every other consumer
+ * of the client. A dedicated connection per migration is the cleanest isolation.
+ */
+export declare class MysqlMigrationRunner {
+    private readonly mysqlConfigProviders;
+    private readonly logHandler;
+    constructor(mysqlConfigProviders: MysqlConfigProviderInterface[], logHandler: LogHandlerInterface);
+    execute(configUniqueKeyname: string, migrationName: string, sql: string): Promise<number>;
+    private resolveConfig;
+}

package/dist/types/managers/mysql-migration-scaffold.manager.d.ts

@@ -0,0 +1,40 @@
+import { LogHandlerInterface } from "@pristine-ts/logging";
+/**
+ * Generates a new `.sql-migrations.ts` file and optionally splices its registration
+ * into a marker-annotated migrations module file. Pure dev-time scaffolding — never
+ * touches the database, never resolved at runtime in production.
+ *
+ * Numbering: scans the target directory for files matching `<digits>-<slug>.sql-migrations.ts`,
+ * picks `max + 1`, and pads to the current width (default 2 digits, never narrows).
+ * If you cross 99 you'll want to rename existing files to 3-digit padding once; the
+ * scaffold respects whichever width it finds.
+ */
+export declare class MysqlMigrationScaffoldManager {
+    private readonly logHandler;
+    private static readonly FilenamePattern;
+    private static readonly ImportsStart;
+    private static readonly ImportsEnd;
+    private static readonly ServicesStart;
+    private static readonly ServicesEnd;
+    constructor(logHandler: LogHandlerInterface);
+    create(options: {
+        scaffoldPath: string;
+        descriptiveName: string;
+        barrelPath?: string;
+        configUniqueKeynames?: string[];
+    }): Promise<{
+        filePath: string;
+        className: string;
+        migrationName: string;
+        barrelUpdated: boolean;
+    }>;
+    renderMigrationFile(className: string, migrationName: string, configUniqueKeynames?: string[]): string;
+    buildClassName(slug: string, paddedNumber: string): string;
+    slugify(input: string): string;
+    private tryUpdateBarrel;
+    private insertSortedBetween;
+    private relativeImportSpecifier;
+    private listExistingNumberPrefixes;
+    private resolveWidth;
+    private exists;
+}

package/dist/types/managers/mysql-migration.manager.d.ts

@@ -0,0 +1,41 @@
+import { LogHandlerInterface } from "@pristine-ts/logging";
+import { MysqlConfigProviderInterface } from "@pristine-ts/mysql";
+import { MysqlMigrationInterface } from "../interfaces/mysql-migration.interface";
+import { MigrationPlan } from "../models/migration-plan.model";
+import { MigrationApplyResult } from "../models/migration-apply-result.model";
+import { MysqlMigrationChecksumManager } from "./mysql-migration-checksum.manager";
+import { MysqlMigrationRecordManager } from "./mysql-migration-record.manager";
+import { MysqlMigrationRunner } from "./mysql-migration-runner.manager";
+/**
+ * Public orchestrator for migration operations. The CLI commands and any deploy-time
+ * runner should depend on this class — never on `MysqlMigrationRunner` /
+ * `MysqlMigrationRecordManager` directly.
+ *
+ * Discovery is DI-based: every migration registered with
+ * `@tag("MysqlMigrationInterface") @injectable()` and reachable through the AppModule's
+ * `importServices` graph is injected here via `@injectAll`. There is no filesystem
+ * scan at apply time, which means this works identically in a bundled Lambda and on
+ * a dev laptop.
+ */
+export declare class MysqlMigrationManager {
+    private readonly registeredMigrations;
+    private readonly mysqlConfigProviders;
+    private readonly recordManager;
+    private readonly runner;
+    private readonly checksumManager;
+    private readonly logHandler;
+    private static readonly DefaultTableName;
+    private static readonly ValidNamePattern;
+    constructor(registeredMigrations: MysqlMigrationInterface[], mysqlConfigProviders: MysqlConfigProviderInterface[], recordManager: MysqlMigrationRecordManager, runner: MysqlMigrationRunner, checksumManager: MysqlMigrationChecksumManager, logHandler: LogHandlerInterface);
+    status(configUniqueKeyname: string): Promise<MigrationPlan>;
+    verify(configUniqueKeyname: string): Promise<MigrationPlan>;
+    apply(configUniqueKeyname: string, options?: {
+        dryRun?: boolean;
+        force?: boolean;
+    }): Promise<MigrationApplyResult>;
+    private resolveConfig;
+    private resolveTableName;
+    private selectMigrations;
+    private buildPlan;
+    private assertNoDrift;
+}

package/dist/types/models/migration-apply-entry.model.d.ts

@@ -0,0 +1,9 @@
+/**
+ * One row of a `MigrationApplyResult`: the outcome of applying a single migration.
+ * `error` is populated only when the migration failed.
+ */
+export declare class MigrationApplyEntry {
+    name: string;
+    executionTimeMs: number;
+    error?: string;
+}

package/dist/types/models/migration-apply-result.model.d.ts

@@ -0,0 +1,14 @@
+import { MigrationApplyEntry } from "./migration-apply-entry.model";
+/**
+ * Output of `MysqlMigrationManager.apply`. `appliedMigrations` is the in-order list
+ * of migrations that ran successfully. `skippedAlreadyApplied` is the list of
+ * names that were already in the database (no-op). `failedMigration` is set when
+ * the run halted on a failure — subsequent pending migrations were not attempted.
+ */
+export declare class MigrationApplyResult {
+    configUniqueKeyname: string;
+    dryRun: boolean;
+    appliedMigrations: MigrationApplyEntry[];
+    skippedAlreadyApplied: string[];
+    failedMigration?: MigrationApplyEntry;
+}

package/dist/types/models/migration-plan-entry.model.d.ts

@@ -0,0 +1,15 @@
+import { MigrationStateEnum } from "../enums/migration-state.enum";
+/**
+ * One row of a `MigrationPlan`: the union view of a single migration as it appears
+ * to both the DI registry and the bookkeeping table. State combines the two views.
+ */
+export declare class MigrationPlanEntry {
+    name: string;
+    state: MigrationStateEnum;
+    /** sha256 of the SQL returned by the registered migration's `up()` — undefined when Orphaned. */
+    diskChecksum?: string;
+    /** sha256 stored at the time of apply — undefined when Pending. */
+    appliedChecksum?: string;
+    /** When the migration was applied — undefined when Pending. */
+    appliedAt?: Date;
+}

package/dist/types/models/migration-plan.model.d.ts

@@ -0,0 +1,14 @@
+import { MigrationStateEnum } from "../enums/migration-state.enum";
+import { MigrationPlanEntry } from "./migration-plan-entry.model";
+/**
+ * Output of `MysqlMigrationManager.status` (and `verify` when no drift exists). The
+ * `entries` array is sorted lexicographically by `name`, matching apply order.
+ */
+export declare class MigrationPlan {
+    configUniqueKeyname: string;
+    tableName: string;
+    entries: MigrationPlanEntry[];
+    hasPending(): boolean;
+    hasDrift(): boolean;
+    countByState(state: MigrationStateEnum): number;
+}

package/dist/types/models/migration-record.model.d.ts

@@ -0,0 +1,12 @@
+/**
+ * One row of the `pristine_migrations` bookkeeping table. Mirrors the schema exactly
+ * (snake_case in the database; the manager handles translation when reading rows
+ * back via `MysqlClient.executeSql`).
+ */
+export declare class MigrationRecord {
+    id: number;
+    filename: string;
+    checksum: string;
+    appliedAt: Date;
+    executionTimeMs?: number;
+}

package/dist/types/models/models.d.ts

@@ -0,0 +1,5 @@
+export * from "./migration-apply-entry.model";
+export * from "./migration-apply-result.model";
+export * from "./migration-plan-entry.model";
+export * from "./migration-plan.model";
+export * from "./migration-record.model";

package/dist/types/mysql-cli.configuration-keys.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Typed configuration keys for `@pristine-ts/mysql-cli`. Use these constants with
+ * `@injectConfig` for autocomplete + rename safety, instead of typing the parameter
+ * name as a string.
+ *
+ * ```ts
+ * import {injectConfig} from "@pristine-ts/common";
+ * import {MysqlCliConfigurationKeys} from "@pristine-ts/mysql-cli";
+ *
+ * constructor(@injectConfig(MysqlCliConfigurationKeys.ScaffoldPath) path: string) {}
+ * ```
+ */
+export declare const MysqlCliConfigurationKeys: {
+    readonly ScaffoldPath: "pristine.mysql-cli.scaffold.path";
+    readonly ScaffoldBarrelPath: "pristine.mysql-cli.scaffold.barrelPath";
+};
+export interface MysqlCliConfigurationValueMap {
+    "pristine.mysql-cli.scaffold.path": string;
+    /**
+     * Empty string means "not set" — the command treats `""` and a real path
+     * differently. `ConfigurationDefinition` does not allow `undefined` defaults,
+     * so we use an empty string as the unset sentinel.
+     */
+    "pristine.mysql-cli.scaffold.barrelPath": string;
+}
+declare module "@pristine-ts/common" {
+    interface PristineConfigurationValueMap extends MysqlCliConfigurationValueMap {
+    }
+}

package/dist/types/mysql-cli.module.d.ts

@@ -0,0 +1,10 @@
+import { ModuleInterface } from "@pristine-ts/common";
+export * from "./commands/commands";
+export * from "./enums/enums";
+export * from "./errors/errors";
+export * from "./interfaces/interfaces";
+export * from "./managers/managers";
+export * from "./models/models";
+export * from "./mysql-cli.configuration-keys";
+export * from "./mysql-cli.module.keyname";
+export declare const MysqlCliModule: ModuleInterface;

package/dist/types/mysql-cli.module.keyname.d.ts

@@ -0,0 +1 @@
+export declare const MysqlCliModuleKeyname: string;