ts-prorm-orm 1.1.0 → 1.2.1

package/dist/cli/keychain.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backend = backend;
+exports.isAvailable = isAvailable;
+exports.setToken = setToken;
+exports.getToken = getToken;
+exports.deleteToken = deleteToken;
+// OS credential-store integration for the prorm CLI access token. Falls back to
+// the plaintext config file when no keychain is available (or when the user opts
+// out via PRORM_NO_KEYCHAIN), so the CLI still works everywhere.
+//
+// Supported backends:
+//   • macOS  — `security` (Keychain)
+//   • Linux  — `secret-tool` (libsecret / GNOME Keyring), when installed
+//   • Windows / others — no native store; falls back to the config file.
+const child_process_1 = require("child_process");
+const SERVICE = 'prorm-cli';
+const ACCOUNT = 'access-token';
+function keychainDisabled() {
+    return Boolean(process.env.PRORM_NO_KEYCHAIN);
+}
+function has(cmd) {
+    try {
+        const which = process.platform === 'win32' ? 'where' : 'which';
+        return (0, child_process_1.spawnSync)(which, [cmd], { stdio: 'ignore' }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** The keychain backend available on this host, or null if none. */
+function backend() {
+    if (keychainDisabled())
+        return null;
+    if (process.platform === 'darwin' && has('security'))
+        return 'macos';
+    if (process.platform === 'linux' && has('secret-tool'))
+        return 'libsecret';
+    return null;
+}
+/** True when a native credential store will be used for the token. */
+function isAvailable() {
+    return backend() !== null;
+}
+/** Store the token in the OS keychain. Returns false if no backend handled it. */
+function setToken(token) {
+    const b = backend();
+    try {
+        if (b === 'macos') {
+            const r = (0, child_process_1.spawnSync)('security', ['add-generic-password', '-U', '-s', SERVICE, '-a', ACCOUNT, '-w', token], { stdio: 'ignore' });
+            return r.status === 0;
+        }
+        if (b === 'libsecret') {
+            const r = (0, child_process_1.spawnSync)('secret-tool', ['store', '--label', SERVICE, 'service', SERVICE, 'account', ACCOUNT], { input: token, stdio: ['pipe', 'ignore', 'ignore'] });
+            return r.status === 0;
+        }
+    }
+    catch {
+        // Fall through to "not stored".
+    }
+    return false;
+}
+/** Read the token from the OS keychain, or undefined if absent/unavailable. */
+function getToken() {
+    const b = backend();
+    try {
+        if (b === 'macos') {
+            const r = (0, child_process_1.spawnSync)('security', ['find-generic-password', '-s', SERVICE, '-a', ACCOUNT, '-w'], {
+                encoding: 'utf8',
+            });
+            if (r.status === 0 && r.stdout)
+                return r.stdout.replace(/\r?\n$/, '');
+        }
+        if (b === 'libsecret') {
+            const r = (0, child_process_1.spawnSync)('secret-tool', ['lookup', 'service', SERVICE, 'account', ACCOUNT], {
+                encoding: 'utf8',
+            });
+            if (r.status === 0 && r.stdout)
+                return r.stdout.replace(/\r?\n$/, '');
+        }
+    }
+    catch {
+        // Ignore — treat as absent.
+    }
+    return undefined;
+}
+/** Delete the token from the OS keychain (best-effort). */
+function deleteToken() {
+    const b = backend();
+    try {
+        if (b === 'macos') {
+            (0, child_process_1.spawnSync)('security', ['delete-generic-password', '-s', SERVICE, '-a', ACCOUNT], { stdio: 'ignore' });
+        }
+        else if (b === 'libsecret') {
+            (0, child_process_1.spawnSync)('secret-tool', ['clear', 'service', SERVICE, 'account', ACCOUNT], { stdio: 'ignore' });
+        }
+    }
+    catch {
+        // Ignore.
+    }
+}

package/dist/cli/prompt.d.ts

@@ -0,0 +1,20 @@
+/**
+ * True when the process can prompt the user: stdin/stdout are TTYs and the user
+ * has not opted out via `--no-input`, PRORM_NO_INPUT, or a CI environment.
+ */
+export declare function isInteractive(): boolean;
+/** Ask a free-text question. Returns `fallback` when non-interactive. */
+export declare function ask(question: string, fallback?: string): Promise<string>;
+/**
+ * Yes/no confirmation. In a TTY the user is prompted; otherwise this returns
+ * `assumeYes` (typically driven by a `--yes` flag) so scripts can pre-confirm.
+ */
+export declare function confirm(message: string, opts?: {
+    assumeYes?: boolean;
+    default?: boolean;
+}): Promise<boolean>;
+/**
+ * Read a line of input without echoing it to the terminal (for tokens and
+ * passwords). Falls back to `fallback` when there is no TTY.
+ */
+export declare function promptHidden(question: string, fallback?: string): Promise<string>;

package/dist/cli/prompt.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteractive = isInteractive;
+exports.ask = ask;
+exports.confirm = confirm;
+exports.promptHidden = promptHidden;
+// Interactive terminal prompts for the prorm CLI. All prompts degrade safely in
+// non-interactive contexts (no TTY, CI, or `--no-input`/PRORM_NO_INPUT), where
+// they resolve to a caller-supplied default rather than hanging on stdin.
+const readline = __importStar(require("readline"));
+const framework_1 = require("./framework");
+/**
+ * True when the process can prompt the user: stdin/stdout are TTYs and the user
+ * has not opted out via `--no-input`, PRORM_NO_INPUT, or a CI environment.
+ */
+function isInteractive() {
+    const g = (0, framework_1.getGlobalOptions)();
+    if (g.noInput)
+        return false;
+    if (process.env.PRORM_NO_INPUT || process.env.CI)
+        return false;
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+/** Ask a free-text question. Returns `fallback` when non-interactive. */
+function ask(question, fallback = '') {
+    if (!isInteractive())
+        return Promise.resolve(fallback);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim() || fallback);
+        });
+    });
+}
+/**
+ * Yes/no confirmation. In a TTY the user is prompted; otherwise this returns
+ * `assumeYes` (typically driven by a `--yes` flag) so scripts can pre-confirm.
+ */
+async function confirm(message, opts = {}) {
+    if (opts.assumeYes)
+        return true;
+    if (!isInteractive())
+        return Boolean(opts.default);
+    const suffix = opts.default ? ' [Y/n] ' : ' [y/N] ';
+    const answer = (await ask(message + suffix)).toLowerCase();
+    if (!answer)
+        return Boolean(opts.default);
+    return answer === 'y' || answer === 'yes';
+}
+/**
+ * Read a line of input without echoing it to the terminal (for tokens and
+ * passwords). Falls back to `fallback` when there is no TTY.
+ */
+function promptHidden(question, fallback = '') {
+    if (!isInteractive())
+        return Promise.resolve(fallback);
+    return new Promise((resolve) => {
+        const input = process.stdin;
+        const output = process.stdout;
+        output.write(question);
+        const rl = readline.createInterface({ input, output, terminal: true });
+        // Mask each keystroke: overwrite whatever readline echoed with nothing.
+        const onKeypress = () => {
+            const len = rl.line.length;
+            readline.moveCursor(output, -len, 0);
+            readline.clearLine(output, 1);
+            output.write(question);
+        };
+        input.on('keypress', onKeypress);
+        rl.question('', (answer) => {
+            input.removeListener('keypress', onKeypress);
+            rl.close();
+            output.write('\n');
+            resolve(answer.trim() || fallback);
+        });
+    });
+}

package/dist/cli.d.ts

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+/**
+ * CLI Tools - Command-line interface for the ORM. This is the single,
+ * canonical CLI implementation exposed via the published `orm-cli` bin.
+ * Provides commands: init, migration:create, migration:run, migration:revert,
+ * migration:status, model:create, seeder:create, db:*, diagram:*
+ *
+ * Usage:
+ *   orm-cli init
+ *   orm-cli migration:create -- --name <migration-name>
+ *   orm-cli migration:run
+ *   orm-cli migration:revert
+ *   orm-cli migration:status
+ *   orm-cli model:create --dialect sqlite --database ./mydb.sqlite
+ *
+ * Model Generator (programmatic):
+ *   CLI.model('User', { name: 'STRING', email: 'STRING' })
+ */
+import { Prorm } from './prorm';
+interface ModelCLIConfig {
+    outputDir: string;
+}
+/**
+ * Configure model generator options
+ */
+declare function configure(options: Partial<ModelCLIConfig>): void;
+/**
+ * Get the output directory for generated models
+ */
+declare function getOutputDir(): string;
+/**
+ * Set the output directory for generated models
+ */
+declare function setOutputDir(dir: string): void;
+/**
+ * Generate a model file from model name and fields
+ * @param modelName - The name of the model (e.g., 'User')
+ * @param fields - Object defining fields (e.g., { name: 'STRING', email: 'STRING' })
+ * @param options - Optional model configuration
+ */
+declare function model(modelName: string, fields: Record<string, string>, options?: {
+    tableName?: string;
+    timestamps?: boolean;
+    paranoid?: boolean;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    allowNull?: boolean;
+    unique?: boolean;
+    defaultValue?: any;
+}): string;
+/**
+ * Generate multiple models at once
+ */
+declare function generateModels(definitions: Record<string, Record<string, string>>): string[];
+/**
+ * Get list of generated model files in the output directory
+ */
+declare function listModels(): string[];
+/**
+ * Remove a generated model file
+ */
+declare function removeModelFile(modelName: string): boolean;
+/**
+ * CLI object for chained usage: CLI.model('User', { ... })
+ */
+declare const CLI: {
+    model: typeof model;
+    generateModels: typeof generateModels;
+    configure: typeof configure;
+    getOutputDir: typeof getOutputDir;
+    setOutputDir: typeof setOutputDir;
+    listModels: typeof listModels;
+    removeModel: typeof removeModelFile;
+};
+interface InitOptions {
+    directory?: string;
+}
+interface CLIConfig {
+    migrationsPath: string;
+    seedersPath: string;
+    verbose: boolean;
+}
+/**
+ * Initialize a new Prorm project
+ */
+declare function init(options?: InitOptions): void;
+/**
+ * Load Prorm instance from environment or config
+ */
+declare function getProrm(): Promise<Prorm>;
+/**
+ * Command: migration:create
+ * Creates a new migration file
+ */
+declare function migrationCreate(name: string, config: CLIConfig): Promise<void>;
+/**
+ * Command: migration:run
+ * Runs pending migrations
+ */
+declare function migrationRun(options: Record<string, string | boolean>, config: CLIConfig): Promise<void>;
+/**
+ * Command: migration:revert
+ * Reverts migrations
+ */
+declare function migrationRevert(options: Record<string, string | boolean>, config: CLIConfig): Promise<void>;
+/**
+ * Command: migration:status
+ * Shows migration status
+ */
+declare function migrationStatus(config: CLIConfig): Promise<void>;
+/**
+ * Command: seeder:create
+ * Creates a new seeder file
+ */
+declare function seederCreate(name: any, config: any): Promise<void>;
+/**
+ * Command: db:seed
+ * Runs all pending seeders, or a single one when --name is given.
+ * --env <name> restricts to seeders whose `env` field matches (or have none).
+ * --force (only valid together with --name) re-runs a seeder even if it was
+ * already recorded as executed.
+ */
+declare function dbSeed(options: any, config: any): Promise<void>;
+/**
+ * Command: db:seed:undo
+ * Undoes a single seeder: the one named by --name, or the most recently
+ * executed one if no --name is given. Use db:seed:undo:all to undo every
+ * executed seeder in reverse order.
+ */
+declare function dbSeedUndo(options: any, config: any): Promise<void>;
+/**
+ * Command: db:seed:undo:all
+ * Undoes every executed seeder, in reverse execution order.
+ */
+declare function dbSeedUndoAll(config: any): Promise<void>;
+/**
+ * Command: db:seed:status
+ * Shows seeder status
+ */
+declare function dbSeedStatus(config: any): Promise<void>;
+/**
+ * Command: diagram:model
+ *
+ * Generates a single-model SVG card.
+ *
+ * Reads model spec from --file <json> or falls back to a minimal stub
+ * using --name <ModelName>.
+ *
+ *   cli diagram:model --file ./User.json --out ./diagrams/User.svg
+ *   cli diagram:model --name Order       --out ./diagrams/Order.svg
+ */
+declare function diagramModel(args: string[]): Promise<void>;
+/**
+ * Command: diagram:er
+ *
+ * Generates a full ER diagram SVG from a schema JSON file.
+ *
+ * Schema JSON format:
+ *   {
+ *     "title": "My Schema",
+ *     "columns": 3,
+ *     "models": [ <model-spec>, ... ]
+ *   }
+ *
+ *   cli diagram:er --file ./schema.json --out ./diagrams/er.svg
+ *   cli diagram:er --file ./schema.json --title "Blog Schema" --columns 2
+ */
+declare function diagramER(args: string[]): Promise<void>;
+/**
+ * Command: diagram:migration
+ *
+ * Generates a migration diagram SVG showing schema changes.
+ *
+ * Migration JSON format:
+ *   {
+ *     "title": "Add email verification",
+ *     "description": "Add email verification fields to users",
+ *     "timestamp": "2024-01-15T10:30:00Z",
+ *     "changes": [
+ *       { "table": "users", "type": "modify", "changes": [
+ *         { "name": "emailVerified", "type": "BOOLEAN", "action": "add" },
+ *         { "name": "verifiedAt", "type": "DATE", "action": "add" }
+ *       ]},
+ *       { "table": "sessions", "type": "add", "changes": [
+ *         { "name": "id", "type": "UUID", "action": "add" },
+ *         { "name": "userId", "type": "UUID", "action": "add" }
+ *       ]}
+ *     ]
+ *   }
+ *
+ *   cli diagram:migration --file ./migration.json --out ./diagrams/migration.svg
+ *   cli diagram:migration --file ./migration.json --title "User Migration"
+ */
+declare function diagramMigration(args: string[]): void;
+/**
+ * Command: model:create
+ * Generate model files from live database table introspection.
+ */
+declare function modelCreateCommand(args: string[]): Promise<void>;
+/**
+ * Command: prisma:import
+ * Converts a Prisma schema.prisma file into prorm model files + an initial
+ * migration. Pure translation only (src/prisma-migrate/) — this command
+ * just handles reading the input file and writing the generated output to
+ * disk, and reports the unsupported-feature errors the converter throws
+ * (implicit many-to-many relations, composite foreign keys, unmapped
+ * Prisma scalar types) as a normal CLI error rather than a stack trace.
+ */
+declare function prismaImportCommand(options: Record<string, string | boolean>): Promise<void>;
+/**
+ * Print the full CLI usage/help text to the console
+ */
+declare function showHelp(): void;
+export { init, CLIConfig, getProrm, migrationCreate, migrationRun, migrationRevert, migrationStatus, showHelp, CLI, model, generateModels, configure, getOutputDir, setOutputDir, listModels, removeModelFile as removeModel, diagramModel, diagramER, diagramMigration, modelCreateCommand, prismaImportCommand, seederCreate, dbSeed, dbSeedUndo, dbSeedUndoAll, dbSeedStatus, };

package/dist/cli.js

@@ -598,6 +598,20 @@ function init(options = {}) {
  * Print colored console output
  */
 function log(message, type = 'info') {
+    const argv = process.argv.slice(2);
+    // Honor --quiet/-q for machine-friendly/silent runs (errors always show).
+    const quiet = argv.includes('--quiet') || argv.includes('-q');
+    if (quiet && type !== 'error')
+        return;
+    // Honor NO_COLOR, --no-color, --color, and FORCE_COLOR for piped output.
+    const forceColor = argv.includes('--color') || (!!process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0');
+    const noColor = argv.includes('--no-color') || !!process.env.NO_COLOR;
+    const useColor = forceColor || (!noColor && !!process.stdout.isTTY);
+    const stream = type === 'error' ? console.error : console.log;
+    if (!useColor) {
+        stream(message);
+        return;
+    }
     const colors = {
         info: '\x1b[36m', // Cyan
         success: '\x1b[32m', // Green
@@ -605,7 +619,7 @@ function log(message, type = 'info') {
         warning: '\x1b[33m', // Yellow
     };
     const reset = '\x1b[0m';
-    console.log(`${colors[type]}${message}${reset}`);
+    stream(`${colors[type]}${message}${reset}`);
 }
 /**
  * Command: db:create
@@ -1941,6 +1955,9 @@ model:create options:
   --table <name>        Specific table to generate a model for (default: all tables)
 
 Diagram options (diagram:model / diagram:er / diagram:migration):
+  Diagrams render in the "Industry" design system by default — a #f2f2f3
+  blueprint ground, white cards with hairline square frames, a solid #5980a6
+  accent header bar, and Barlow / JetBrains Mono type. Flags below override it.
   --file <path>         JSON spec file (model/ER schema/migration)
   --db <conn-string>    Database connection string (generates diagram from DB)
   --table <name>        Table name for model diagram (with --db)
@@ -1948,7 +1965,9 @@ Diagram options (diagram:model / diagram:er / diagram:migration):
   --title <title>       ER/migration diagram title
   --columns <n>         Number of columns in ER grid layout (default: 3)
   --theme <theme>       Theme: light or dark (default: light)
-  --color <color>       Accent color: blue, violet, emerald, amber, pink, sky, indigo, purple, red, teal, green
+  --color <color>       Accent: industry (default), industry-2, blue, violet,
+                        emerald, amber, pink, sky, indigo, purple, red, teal,
+                        green, stone — or a #hex color
   --description <desc>  Migration description (diagram:migration only)
 
 prisma:import options:
@@ -1998,7 +2017,7 @@ Examples:
   # Use custom migrations path
   cli migration:run -- --path ./db/migrations
 
-  # Generate a model diagram from a JSON spec
+  # Generate a model diagram from a JSON spec (Industry design by default)
   cli diagram:model --file ./User.json --out ./diagrams/User.svg
 
   # Generate an ER diagram from a schema JSON (multiple models)
@@ -2010,7 +2029,10 @@ Examples:
   # Generate diagram from database (for documentation)
   cli diagram:er --db sqlite:./database.db --out ./diagrams/schema.svg
   cli diagram:model --db mysql://root:pass@localhost:3306/mydb --table users --out ./diagrams/User.svg
+
+  # Override the default Industry accent (named palette, or a #hex)
   cli diagram:er --db postgres://user:pass@localhost:5432/mydb --title "Production DB" --color violet
+  cli diagram:model --name User --color '#5980a6' --theme dark --out ./diagrams/User.svg
 
   # Extended visualizers — each reads its own JSON spec (--file) and writes SVG (--out)
   cli diagram:class      --file ./classes.json    --out ./diagrams/classes.svg
@@ -2194,7 +2216,52 @@ function main() {
         }
     })();
 }
-// Run if executed directly (not when imported as a module)
-if (require.main === module) {
+// Run if executed directly (not when imported as a module). Cloud/account
+// commands (auth, pull, db, store, team, key, …) are handled by the modular
+// registry under ./cli; anything it doesn't recognise falls through to the
+// legacy synchronous main() (init, migration:*, model:create, db:*, diagram:*).
+async function bootstrap() {
+    const argv = process.argv.slice(2);
+    try {
+        const framework = await Promise.resolve().then(() => __importStar(require('./cli/framework')));
+        await Promise.resolve().then(() => __importStar(require('./cli/commands'))); // side effect: registers all command modules
+        // Top-level help must surface the cloud commands (auth/db/store/…) that the
+        // registry owns, not just the legacy migration/diagram set. Print the
+        // registry's grouped help first, then fall through to the legacy list below.
+        if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
+            console.log(framework.topLevelHelp());
+            console.log('\nLegacy project commands (migrations, diagrams, scaffolding):');
+        }
+        else {
+            const code = await framework.runRegistered(argv);
+            if (code !== null) {
+                process.exit(code);
+            }
+            // Unknown to the registry and not obviously a legacy command — suggest.
+            const first = argv[0];
+            const LEGACY = new Set([
+                'init', 'model:create', 'migration:create', 'migration:run', 'migration:revert',
+                'migration:status', 'db:create', 'db:drop', 'seeder:create', 'db:seed',
+                'db:seed:undo', 'db:seed:undo:all', 'db:seed:status', 'prisma:import',
+            ]);
+            if (first && !first.startsWith('-') && !first.startsWith('diagram:') && !LEGACY.has(first)) {
+                const suggestion = framework.suggestCommand(first);
+                if (suggestion) {
+                    console.error(`Unknown command: ${first}. Did you mean \`${suggestion}\`?`);
+                    console.error('Run `orm-cli --help` to see all commands.');
+                    process.exit(2);
+                }
+            }
+        }
+    }
+    catch (err) {
+        // If the registry itself fails to load, fall back to legacy handling rather
+        // than break the whole CLI.
+        if (process.env.PRORM_DEBUG)
+            console.error(err);
+    }
     main();
 }
+if (require.main === module) {
+    bootstrap();
+}

package/dist/compliance/audit-trail.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ComplianceAuditTrail
+ *
+ * A one-liner mixin that enables persistent audit logging on any model.
+ * Wraps the existing AuditLogger from src/audit/logger.ts.
+ *
+ * Covers ~64 compliance frameworks including:
+ *   GDPR Art 32, HIPAA, SOX, PCI DSS, SOC 2, ISO 27001, CJIS, FINRA,
+ *   21 CFR Part 11, ALCOA+, GAMP 5, ICH E6, NIST SP 800-53, and more.
+ *
+ * Usage:
+ *   const trail = ComplianceAuditTrail.enable(prorm, User, {
+ *     getUserId: () => currentUser.id,
+ *     getIpAddress: () => req.ip,
+ *   });
+ *
+ *   // Query the audit log:
+ *   const logs = await trail.getHistory('Users', userId);
+ */
+import { AuditLogger, AuditLog } from '../audit/logger';
+export interface AuditTrailOptions {
+    /** Return the current user ID for the audit record */
+    getUserId?: () => string | number | undefined;
+    /** Return the current request IP address */
+    getIpAddress?: () => string | undefined;
+    /** Override the audit table name. Default: 'ComplianceAuditLogs' */
+    tableName?: string;
+}
+export declare class ComplianceAuditTrail {
+    private logger;
+    private modelName;
+    private constructor();
+    /**
+     * Enable audit logging on a model. Call once per model at app startup.
+     *
+     * @param prorm - The Prorm instance
+     * @param model     - The model class to audit
+     * @param options   - Optional configuration
+     * @returns A ComplianceAuditTrail instance for querying history
+     */
+    static enable(prorm: any, model: any, options?: AuditTrailOptions): ComplianceAuditTrail;
+    /**
+     * Query the audit history for a table.
+     *
+     * @param tableName - The table/model name to query
+     * @param recordId  - Optional: filter to a specific record ID
+     * @param options   - Pagination and date range filters
+     */
+    getHistory(tableName: string, recordId?: string | number, options?: {
+        limit?: number;
+        offset?: number;
+        startDate?: Date;
+        endDate?: Date;
+    }): Promise<AuditLog[]>;
+    /**
+     * Get the audit history for the model this trail is attached to.
+     */
+    getModelHistory(recordId?: string | number, options?: {
+        limit?: number;
+        offset?: number;
+        startDate?: Date;
+        endDate?: Date;
+    }): Promise<AuditLog[]>;
+    /** Expose the underlying AuditLogger for advanced use. */
+    getLogger(): AuditLogger;
+}