mango-orm 1.1.2 → 1.1.4

package/dist/{src/cli.js → cli.js}

@@ -27,12 +27,13 @@ switch (command) {
 }
 function showHelp() {
     console.log(chalk.bold("Usage:"));
-    console.log("  npm run migration:generate <name> [outputDir]\n");
+    console.log("  mango generate <name> [outputDir]");
+    console.log("  npx mango generate <name> [outputDir]\n");
     console.log(chalk.bold("Commands:"));
     console.log(chalk.cyan("  generate, g") + "    Generate a new migration file");
     console.log(chalk.cyan("  help, -h") + "        Show this help message\n");
     console.log(chalk.bold("Examples:"));
-    console.log("  npm run migration:generate create_users_table");
-    console.log("  npm run migration:generate add_email_column");
-    console.log("  npm run migration:generate create_posts_table ./db/migrations\n");
+    console.log("  mango generate create_users_table");
+    console.log("  mango generate add_email_column");
+    console.log("  mango generate create_posts_table ./db/migrations\n");
 }

package/dist/mango.d.ts

@@ -0,0 +1,114 @@
+import * as sql from "mysql";
+declare class MangoType {
+    private query;
+    constructor();
+    int(): this;
+    bigInt(): this;
+    float(): this;
+    char(length: number): this;
+    text(): this;
+    date(): this;
+    dateTime(): this;
+    timeStamp(): this;
+    boolean(): this;
+    tinyInt(length: number): this;
+    autoIncrement(): this;
+    primaryKey(): this;
+    varchar(length: number): this;
+    notNull(): this;
+    unique(): this;
+    getQuery(): string;
+}
+declare class MangoQuery {
+    private db;
+    query: string;
+    supplies: any;
+    config(db: sql.Pool): void;
+    execute<T>(): Promise<T>;
+    customQuery<T>(query: string, supplies: any[]): Promise<T>;
+}
+declare class MangoTable<T> {
+    private db;
+    private tableName;
+    private tableFields;
+    private query;
+    constructor(db: sql.Pool, name: string, fields?: string[]);
+    addColumns(fields: Record<string, MangoType>): this;
+    removeColumns(fields: string[]): this;
+    selectAll(): this;
+    selectColumns(columns: string[]): this;
+    selectDistinctColumns(columns: string[]): this;
+    orderBy(columnName: string): this;
+    sort(sort?: number): this;
+    limit(length: number): this;
+    offset(length: number): this;
+    insertOne(data: Record<string, any>): this;
+    insertMany(fields: string[], data?: any[][]): this;
+    getFields(): string[];
+    getName(): string;
+    truncate(): this;
+    where(field: string, operator: string, value: any): this;
+    and(field: string, operator: string, value: any): this;
+    or(field: string, operator: string, value: any): this;
+    update(data: Record<string, any>): this;
+    join(type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL', table: string, condition: {
+        left: string;
+        operator: string;
+        right: string;
+    }): this;
+    delete(): this;
+    whereIn(field: string, values: any[]): this;
+    whereNotIn(field: string, values: any[]): this;
+    getQuery(): MangoQuery;
+    execute(): Promise<T[]>;
+    customQuery<Type>(query: string, supplies: any[]): Promise<Type[]>;
+}
+declare class Mango {
+    private db;
+    private tables;
+    private query;
+    connect({ host, user, password, database, connectionLimit, waitForConnection, queueLimit, connectTimeout, charset, }: {
+        host: any;
+        user: any;
+        password: any;
+        database: any;
+        connectionLimit?: number;
+        waitForConnection?: boolean;
+        queueLimit?: number;
+        connectTimeout?: number;
+        charset?: string;
+    }): Promise<this>;
+    disconnect(): Promise<void>;
+    types(): MangoType;
+    selectTable<T = any>(name: string): MangoTable<T>;
+    getTables(): MangoTable<any>[];
+    createTable<T>(name: string, fields: Record<string, MangoType>): Promise<MangoTable<T>>;
+    dropTable(name: string): Promise<void>;
+    haveTable(name: string): boolean;
+    customQuery<Type>(query: string, supplies: any[]): Promise<Type>;
+}
+interface IMangoMigrationType {
+    name: string;
+    timestamp: number;
+    up: (mango: Mango) => Promise<void>;
+    down: (mango: Mango) => Promise<void>;
+}
+declare class MangoMigration {
+    private mango;
+    private mango_migration_table_name;
+    private migrations;
+    private initialize;
+    constructor(mango: Mango);
+    private addOneMigrationToDB;
+    private addManyMigrationToDB;
+    private deleteOneMigrationFromDB;
+    private deleteManyMigrationFromDB;
+    add(migration: IMangoMigrationType): MangoMigration;
+    private getExecutedMigrations;
+    migrateUp(): Promise<void>;
+    migrateUpToLatest(): Promise<void>;
+    migrateDown(): Promise<void>;
+    migrateDownToOldest(): Promise<void>;
+    status(): Promise<void>;
+}
+export { Mango, MangoType, MangoTable, MangoMigration, IMangoMigrationType };

package/dist/{src/mango.js → mango.js}

@@ -1,135 +1,84 @@
-/*
-  Requires sql for connection
-*/
 import * as sql from "mysql";
 import chalk from "chalk";
-/**
- * MangoType - Schema builder for defining table column types
- * Provides chainable methods to build SQL column definitions
- *
- * @example
- * const type = new MangoType();
- * type.varchar(255).notNull().unique();
- */
 class MangoType {
     constructor() {
         this.query = "";
     }
-    /** Define an INT column */
     int() {
         this.query += " INT ";
         return this;
     }
-    /** Define a BIGINT column */
     bigInt() {
         this.query += " BIGINT ";
         return this;
     }
-    /** Define a FLOAT column */
     float() {
         this.query += " FLOAT ";
         return this;
     }
-    /**
-     * Define a CHAR column with fixed length
-     * @param length - The fixed character length
-     */
     char(length) {
         this.query += ` CHAR(${length}) `;
         return this;
     }
-    /** Define a TEXT column for large text data */
     text() {
         this.query += " TEXT ";
         return this;
     }
-    /** Define a DATE column (YYYY-MM-DD) */
     date() {
         this.query += " DATE ";
         return this;
     }
-    /** Define a DATETIME column (YYYY-MM-DD HH:MM:SS) */
     dateTime() {
         this.query += " DATETIME ";
         return this;
     }
-    /** Define a TIMESTAMP column (auto-updated on changes) */
     timeStamp() {
         this.query += " TIMESTAMP ";
         return this;
     }
-    /** Define a BOOLEAN column (stored as TINYINT(1)) */
     boolean() {
         this.query += " BOOLEAN ";
         return this;
     }
-    /**
-     * Define a TINYINT column
-     * @param length - Display width (e.g., TINYINT(1))
-     */
     tinyInt(length) {
         this.query += ` TINYINT(${length})`;
         return this;
     }
-    /** Make column auto-incrementing (use with INT/BIGINT) */
     autoIncrement() {
         this.query += " AUTO_INCREMENT ";
         return this;
     }
-    /** Mark column as primary key */
     primaryKey() {
         this.query += " PRIMARY KEY ";
         return this;
     }
-    /**
-     * Define a VARCHAR column with variable length
-     * @param length - Maximum character length (e.g., 255)
-     */
     varchar(length) {
         this.query += ` VARCHAR(${length}) `;
         return this;
     }
-    /** Make column NOT NULL (required field) */
     notNull() {
         this.query += ` NOT NULL `;
         return this;
     }
-    /** Add UNIQUE constraint (no duplicate values) */
     unique() {
         this.query += " UNIQUE ";
         return this;
     }
-    /** Get the built SQL column definition */
     getQuery() {
         return this.query;
     }
 }
-/**
- * MangoQuery - Internal query executor
- * Handles SQL query execution and prepared statements
- * Automatically resets state after execution to prevent query contamination
- */
 class MangoQuery {
     constructor() {
         this.query = "";
-        this.supplies = []; // Prepared statement parameters
+        this.supplies = [];
     }
-    /**
-     * Configure the database connection pool
-     * @param db - MySQL connection pool instance
-     */
     config(db) {
         this.db = db;
     }
-    /**
-     * Execute the built query with prepared statements
-     * Automatically resets query and supplies after execution
-     * @returns Promise resolving to query results
-     */
     execute() {
         return new Promise((resolve, reject) => {
             this.db.query(this.query, this.supplies, (err, result) => {
-                // Reset state BEFORE resolving to prevent contamination
                 this.query = "";
                 this.supplies = [];
                 if (err)
@@ -139,13 +88,6 @@ class MangoQuery {
             });
         });
     }
-    /**
-     * Execute a custom SQL query with parameters
-     * Use for complex queries not covered by the query builder
-     * @param query - Raw SQL query string
-     * @param supplies - Array of parameter values
-     * @returns Promise resolving to query results
-     */
     customQuery(query, supplies) {
         return new Promise((resolve, reject) => {
             this.db.query(query, supplies, (err, result) => {
@@ -157,53 +99,21 @@ class MangoQuery {
         });
     }
 }
-/**
- * MangoTable<T> - Main query builder class for table operations
- * Provides chainable methods for building SQL queries
- * Generic type T represents the shape of table rows
- *
- * @example
- * const users = new MangoTable(db, 'users', ['id', 'name', 'email']);
- * const result = await users.selectAll().where('id', '=', 1).execute();
- */
 class MangoTable {
-    /**
-     * Create a new table instance
-     * @param db - MySQL connection pool
-     * @param name - Table name (no spaces allowed)
-     * @param fields - Array of column names in the table
-     */
     constructor(db, name, fields = []) {
         this.query = new MangoQuery();
-        // Validate that fields are provided
         if (fields.length == 0 || (fields.length == 1 && fields[0] === "")) {
             throw new Error("no fields provided for table " + name);
         }
         this.db = db;
-        // Validate table name doesn't contain spaces
         if (Array.from(name.split(" ")).length > 1) {
             throw new Error("No spaces in table name allowed:");
         }
         this.tableName = name.toLowerCase();
-        this.tableFields = [...fields]; // Clone to prevent external mutations
-        // Initialize query executor
-        // this.query = new MangoQuery();
+        this.tableFields = [...fields];
         this.query.config(db);
     }
-    /**
-     * Add new columns to an existing table
-     * Updates internal field list for validation
-     * @param fields - Object mapping column names to MangoType definitions
-     * @returns this for method chaining
-     *
-     * @example
-     * table.addColumns({
-     *   age: mango.types().int().notNull(),
-     *   status: mango.types().varchar(50)
-     * }).execute();
-     */
     addColumns(fields) {
-        // Early return if no fields provided
         if (Object.entries(fields).length === 0)
             return this;
         this.query.query += "ALTER TABLE " + this.tableName + "\n";
@@ -211,7 +121,6 @@ class MangoTable {
         this.query.query += entries
             .map(([key, value]) => {
             let QUERY = " ADD COLUMN ";
-            // Validate column name doesn't contain spaces
             if (Array.from(key.split(" ")).length > 1) {
                 throw new Error("Field/Column name cannot have spaces: " +
                     key +
@@ -224,28 +133,16 @@ class MangoTable {
         })
             .join(",\n");
         this.query.query += ";\n";
-        // Update internal field list for future validations
         entries.forEach(([key]) => this.tableFields.push(key));
         return this;
     }
-    /**
-     * Remove columns from the table
-     * Validates columns exist before removal
-     * @param fields - Array of column names to remove
-     * @returns this for method chaining
-     *
-     * @example
-     * table.removeColumns(['old_field', 'deprecated_col']).execute();
-     */
     removeColumns(fields) {
-        // Early return if no fields provided
         if (fields.length === 0)
             return this;
         this.query.query += "ALTER TABLE " + this.tableName + "\n";
         this.query.query += fields
             .map((field) => {
             let QUERY = " DROP COLUMN ";
-            // Validate field exists in table
             if (!this.tableFields.includes(field)) {
                 throw new Error("field/column : " +
                     field +
@@ -257,38 +154,18 @@ class MangoTable {
         })
             .join(",\n");
         this.query.query += ";\n";
-        // Remove fields from internal tracking
         this.tableFields = this.tableFields.filter((value) => !fields.includes(value));
         return this;
     }
-    /**
-     * Select all columns from the table
-     * @returns this for method chaining
-     *
-     * @example
-     * await table.selectAll().where('active', '=', true).execute();
-     */
     selectAll() {
         this.query.query = `SELECT * from ${this.tableName}`;
         return this;
     }
-    /**
-     * Select specific columns from the table
-     * Validates all columns exist before building query
-     * @param columns - Array of column names to select
-     * @returns this for method chaining
-     *
-     * @example
-     * await table.selectColumns(['id', 'name', 'email']).execute();
-     */
     selectColumns(columns) {
-        // Early return if no columns specified
         if (columns.length === 0)
             return this;
         this.query.query = `SELECT `;
-        // Build column list with proper comma separation
         for (let i = 0; i < columns.length; i++) {
-            // Validate each column exists in table
             if (!this.tableFields.includes(columns[i])) {
                 throw new Error("Table field: " +
                     columns[i] +
@@ -296,7 +173,6 @@ class MangoTable {
                     this.tableName);
             }
             this.query.query += " " + columns[i];
-            // Add comma between columns, but not after the last one
             if (i < columns.length - 1) {
                 this.query.query += " , ";
             }
@@ -399,26 +275,10 @@ class MangoTable {
         this.query.query = " TRUNCATE TABLE " + this.tableName;
         return this;
     }
-    /**
-     * Add WHERE clause to filter query results
-     * Use with comparison operators to filter rows
-     * Supports falsy values (0, false, empty string)
-     * @param field - Column name to filter on
-     * @param operator - SQL comparison operator (=, !=, <, >, LIKE, etc.)
-     * @param value - Value to compare against (any type)
-     * @returns this for method chaining
-     *
-     * @example
-     * table.selectAll().where('age', '>=', 18).execute();
-     * table.selectAll().where('active', '=', false).execute(); // Works with false!
-     * table.selectAll().where('count', '=', 0).execute(); // Works with 0!
-     */
     where(field, operator, value) {
-        // Validate field exists in table
         if (!this.tableFields.includes(field)) {
             throw new Error(`Field/Column: ${field} does not exist in table: ${this.tableName}`);
         }
-        // Validate operator is allowed
         const validOperators = [
             "=",
             "!=",
@@ -437,25 +297,10 @@ class MangoTable {
         if (!validOperators.includes(operator.toUpperCase())) {
             throw new Error(`Invalid operator: ${operator}`);
         }
-        // Build WHERE clause with placeholder
         this.query.query += ` WHERE ${field} ${operator} ? `;
         this.query.supplies.push(value);
         return this;
     }
-    /**
-     * Add AND condition to existing WHERE clause
-     * Chain multiple conditions together
-     * @param field - Column name
-     * @param operator - SQL comparison operator
-     * @param value - Value to compare (any type including 0, false)
-     * @returns this for method chaining
-     *
-     * @example
-     * table.selectAll()
-     *   .where('age', '>=', 18)
-     *   .and('active', '=', true)
-     *   .execute();
-     */
     and(field, operator, value) {
         if (!this.tableFields.includes(field)) {
             throw new Error(`Field/Column: ${field} does not exist in table: ${this.tableName}`);
@@ -482,20 +327,6 @@ class MangoTable {
         this.query.supplies.push(value);
         return this;
     }
-    /**
-     * Add OR condition to existing WHERE clause
-     * Combine alternative conditions
-     * @param field - Column name
-     * @param operator - SQL comparison operator
-     * @param value - Value to compare (any type including 0, false)
-     * @returns this for method chaining
-     *
-     * @example
-     * table.selectAll()
-     *   .where('role', '=', 'admin')
-     *   .or('role', '=', 'moderator')
-     *   .execute();
-     */
     or(field, operator, value) {
         if (!this.tableFields.includes(field)) {
             throw new Error(`Field/Column: ${field} does not exist in table: ${this.tableName}`);
@@ -584,26 +415,9 @@ class MangoTable {
         return this.query.customQuery(query, supplies);
     }
 }
-/**
- * Mango - Main ORM class for MySQL database operations
- * Manages connection pool and provides table instances
- * Auto-discovers existing tables on connection
- *
- * @example
- * const mango = new Mango();
- * await mango.connect({
- *   host: 'localhost',
- *   user: 'root',
- *   password: 'pass',
- *   database: 'mydb'
- * });
- *
- * const users = mango.selectTable('users');
- * const results = await users.selectAll().execute();
- */
 class Mango {
     constructor() {
-        this.tables = []; // Cached table instances
+        this.tables = [];
         this.query = new MangoQuery();
     }
     async connect({ host, user, password, database, connectionLimit = 10, waitForConnection = true, queueLimit = 0, connectTimeout = 10000, charset = "utf8mb4", }) {
@@ -640,27 +454,9 @@ class Mango {
             });
         });
     }
-    /**
-     * Get a new MangoType instance for schema building
-     * Use when creating or modifying table columns
-     * @returns New MangoType instance for chaining
-     *
-     * @example
-     * const idField = mango.types().int().autoIncrement().primaryKey();
-     */
     types() {
         return new MangoType();
     }
-    /**
-     * Get a table instance by name
-     * Returns strongly-typed table if generic provided
-     * @param name - Name of the table
-     * @returns MangoTable instance for building queries
-     *
-     * @example
-     * interface User { id: number; name: string; email: string }
-     * const users = mango.selectTable<User>('users');
-     */
     selectTable(name) {
         for (const table of this.tables) {
             if (table.getName() == name.toLowerCase()) {
@@ -669,10 +465,6 @@ class Mango {
         }
         throw new Error("Table not found: " + name);
     }
-    /**
-     * Get all discovered table instances
-     * @returns Array of all MangoTable instances
-     */
     getTables() {
         return [...this.tables];
     }
@@ -691,14 +483,12 @@ class Mango {
             }
         });
         this.query.query += "\n)";
-        // console.log(this.query.query);
         await this.query.execute();
         this.query.query = "";
         this.tables.push(table);
         return table;
     }
     async dropTable(name) {
-        // Find and remove from tables array first
         for (let i = 0; i < this.tables.length; i++) {
             if (this.tables[i].getName() === name.toLowerCase()) {
                 this.query.query = "DROP TABLE " + name.toLowerCase();
@@ -929,5 +719,4 @@ class MangoMigration {
     }
 }
 ;
-export { Mango, MangoType, MangoTable };
-export { MangoMigration };
+export { Mango, MangoType, MangoTable, MangoMigration };

package/dist/{src/migration-cli.js → migration-cli.js}

@@ -4,7 +4,7 @@ import path from "path";
 const generateMangoMigrationFile = (migrationFilename, outputDir = './migrations') => {
     const timestamp = Date.now();
     const filepath = path.join(outputDir, `${timestamp}_${migrationFilename}.ts`);
-    const template = `import { IMangoMigrationType, Mango } from "../src/mango.js";
+    const template = `import { IMangoMigrationType, Mango } from "mango-orm;
 
 export const ${migrationFilename}: IMangoMigrationType = {
     name: "${migrationFilename}",

package/package.json

@@ -1,21 +1,19 @@
 {
   "name": "mango-orm",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "type": "module",
   "description": "A lightweight, type-safe MySQL ORM for Node.js and TypeScript with database migrations",
-  "main": "dist/src/mango.js",
-  "types": "dist/src/mango.d.ts",
+  "main": "dist/mango.js",
+  "types": "dist/mango.d.ts",
+  "bin": {
+    "mango": "./dist/cli.js"
+  },
   "scripts": {
     "build": "tsc",
-    "dev": "tsc --watch",
-    "test": "tsc && node dist/test/test.js",
-    "test:ops": "tsc && node dist/test/test-operations.js",
-    "prepublishOnly": "pnpm build",
-    "migration:generate": "tsc && node dist/src/cli.js generate",
-    "migration:help": "tsc && node dist/src/cli.js help"
+    "prepublishOnly": "pnpm build"
   },
   "files": [
-    "dist/src",
+    "dist",
     "README.md",
     "LICENSE"
   ],

package/dist/src/mango.d.ts

@@ -1,302 +0,0 @@
-import * as sql from "mysql";
-/**
- * MangoType - Schema builder for defining table column types
- * Provides chainable methods to build SQL column definitions
- *
- * @example
- * const type = new MangoType();
- * type.varchar(255).notNull().unique();
- */
-declare class MangoType {
-    private query;
-    constructor();
-    /** Define an INT column */
-    int(): this;
-    /** Define a BIGINT column */
-    bigInt(): this;
-    /** Define a FLOAT column */
-    float(): this;
-    /**
-     * Define a CHAR column with fixed length
-     * @param length - The fixed character length
-     */
-    char(length: number): this;
-    /** Define a TEXT column for large text data */
-    text(): this;
-    /** Define a DATE column (YYYY-MM-DD) */
-    date(): this;
-    /** Define a DATETIME column (YYYY-MM-DD HH:MM:SS) */
-    dateTime(): this;
-    /** Define a TIMESTAMP column (auto-updated on changes) */
-    timeStamp(): this;
-    /** Define a BOOLEAN column (stored as TINYINT(1)) */
-    boolean(): this;
-    /**
-     * Define a TINYINT column
-     * @param length - Display width (e.g., TINYINT(1))
-     */
-    tinyInt(length: number): this;
-    /** Make column auto-incrementing (use with INT/BIGINT) */
-    autoIncrement(): this;
-    /** Mark column as primary key */
-    primaryKey(): this;
-    /**
-     * Define a VARCHAR column with variable length
-     * @param length - Maximum character length (e.g., 255)
-     */
-    varchar(length: number): this;
-    /** Make column NOT NULL (required field) */
-    notNull(): this;
-    /** Add UNIQUE constraint (no duplicate values) */
-    unique(): this;
-    /** Get the built SQL column definition */
-    getQuery(): string;
-}
-/**
- * MangoQuery - Internal query executor
- * Handles SQL query execution and prepared statements
- * Automatically resets state after execution to prevent query contamination
- */
-declare class MangoQuery {
-    private db;
-    query: string;
-    supplies: any;
-    /**
-     * Configure the database connection pool
-     * @param db - MySQL connection pool instance
-     */
-    config(db: sql.Pool): void;
-    /**
-     * Execute the built query with prepared statements
-     * Automatically resets query and supplies after execution
-     * @returns Promise resolving to query results
-     */
-    execute<T>(): Promise<T>;
-    /**
-     * Execute a custom SQL query with parameters
-     * Use for complex queries not covered by the query builder
-     * @param query - Raw SQL query string
-     * @param supplies - Array of parameter values
-     * @returns Promise resolving to query results
-     */
-    customQuery<T>(query: string, supplies: any[]): Promise<T>;
-}
-/**
- * MangoTable<T> - Main query builder class for table operations
- * Provides chainable methods for building SQL queries
- * Generic type T represents the shape of table rows
- *
- * @example
- * const users = new MangoTable(db, 'users', ['id', 'name', 'email']);
- * const result = await users.selectAll().where('id', '=', 1).execute();
- */
-declare class MangoTable<T> {
-    private db;
-    private tableName;
-    private tableFields;
-    private query;
-    /**
-     * Create a new table instance
-     * @param db - MySQL connection pool
-     * @param name - Table name (no spaces allowed)
-     * @param fields - Array of column names in the table
-     */
-    constructor(db: sql.Pool, name: string, fields?: string[]);
-    /**
-     * Add new columns to an existing table
-     * Updates internal field list for validation
-     * @param fields - Object mapping column names to MangoType definitions
-     * @returns this for method chaining
-     *
-     * @example
-     * table.addColumns({
-     *   age: mango.types().int().notNull(),
-     *   status: mango.types().varchar(50)
-     * }).execute();
-     */
-    addColumns(fields: Record<string, MangoType>): this;
-    /**
-     * Remove columns from the table
-     * Validates columns exist before removal
-     * @param fields - Array of column names to remove
-     * @returns this for method chaining
-     *
-     * @example
-     * table.removeColumns(['old_field', 'deprecated_col']).execute();
-     */
-    removeColumns(fields: string[]): this;
-    /**
-     * Select all columns from the table
-     * @returns this for method chaining
-     *
-     * @example
-     * await table.selectAll().where('active', '=', true).execute();
-     */
-    selectAll(): this;
-    /**
-     * Select specific columns from the table
-     * Validates all columns exist before building query
-     * @param columns - Array of column names to select
-     * @returns this for method chaining
-     *
-     * @example
-     * await table.selectColumns(['id', 'name', 'email']).execute();
-     */
-    selectColumns(columns: string[]): this;
-    selectDistinctColumns(columns: string[]): this;
-    orderBy(columnName: string): this;
-    sort(sort?: number): this;
-    limit(length: number): this;
-    offset(length: number): this;
-    insertOne(data: Record<string, any>): this;
-    insertMany(fields: string[], data?: any[][]): this;
-    getFields(): string[];
-    getName(): string;
-    truncate(): this;
-    /**
-     * Add WHERE clause to filter query results
-     * Use with comparison operators to filter rows
-     * Supports falsy values (0, false, empty string)
-     * @param field - Column name to filter on
-     * @param operator - SQL comparison operator (=, !=, <, >, LIKE, etc.)
-     * @param value - Value to compare against (any type)
-     * @returns this for method chaining
-     *
-     * @example
-     * table.selectAll().where('age', '>=', 18).execute();
-     * table.selectAll().where('active', '=', false).execute(); // Works with false!
-     * table.selectAll().where('count', '=', 0).execute(); // Works with 0!
-     */
-    where(field: string, operator: string, value: any): this;
-    /**
-     * Add AND condition to existing WHERE clause
-     * Chain multiple conditions together
-     * @param field - Column name
-     * @param operator - SQL comparison operator
-     * @param value - Value to compare (any type including 0, false)
-     * @returns this for method chaining
-     *
-     * @example
-     * table.selectAll()
-     *   .where('age', '>=', 18)
-     *   .and('active', '=', true)
-     *   .execute();
-     */
-    and(field: string, operator: string, value: any): this;
-    /**
-     * Add OR condition to existing WHERE clause
-     * Combine alternative conditions
-     * @param field - Column name
-     * @param operator - SQL comparison operator
-     * @param value - Value to compare (any type including 0, false)
-     * @returns this for method chaining
-     *
-     * @example
-     * table.selectAll()
-     *   .where('role', '=', 'admin')
-     *   .or('role', '=', 'moderator')
-     *   .execute();
-     */
-    or(field: string, operator: string, value: any): this;
-    update(data: Record<string, any>): this;
-    join(type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL', table: string, condition: {
-        left: string;
-        operator: string;
-        right: string;
-    }): this;
-    delete(): this;
-    whereIn(field: string, values: any[]): this;
-    whereNotIn(field: string, values: any[]): this;
-    getQuery(): MangoQuery;
-    execute(): Promise<T[]>;
-    customQuery<Type>(query: string, supplies: any[]): Promise<Type[]>;
-}
-/**
- * Mango - Main ORM class for MySQL database operations
- * Manages connection pool and provides table instances
- * Auto-discovers existing tables on connection
- *
- * @example
- * const mango = new Mango();
- * await mango.connect({
- *   host: 'localhost',
- *   user: 'root',
- *   password: 'pass',
- *   database: 'mydb'
- * });
- *
- * const users = mango.selectTable('users');
- * const results = await users.selectAll().execute();
- */
-declare class Mango {
-    private db;
-    private tables;
-    private query;
-    connect({ host, user, password, database, connectionLimit, waitForConnection, queueLimit, connectTimeout, charset, }: {
-        host: any;
-        user: any;
-        password: any;
-        database: any;
-        connectionLimit?: number;
-        waitForConnection?: boolean;
-        queueLimit?: number;
-        connectTimeout?: number;
-        charset?: string;
-    }): Promise<this>;
-    disconnect(): Promise<void>;
-    /**
-     * Get a new MangoType instance for schema building
-     * Use when creating or modifying table columns
-     * @returns New MangoType instance for chaining
-     *
-     * @example
-     * const idField = mango.types().int().autoIncrement().primaryKey();
-     */
-    types(): MangoType;
-    /**
-     * Get a table instance by name
-     * Returns strongly-typed table if generic provided
-     * @param name - Name of the table
-     * @returns MangoTable instance for building queries
-     *
-     * @example
-     * interface User { id: number; name: string; email: string }
-     * const users = mango.selectTable<User>('users');
-     */
-    selectTable<T = any>(name: string): MangoTable<T>;
-    /**
-     * Get all discovered table instances
-     * @returns Array of all MangoTable instances
-     */
-    getTables(): MangoTable<any>[];
-    createTable<T>(name: string, fields: Record<string, MangoType>): Promise<MangoTable<T>>;
-    dropTable(name: string): Promise<void>;
-    haveTable(name: string): boolean;
-    customQuery<Type>(query: string, supplies: any[]): Promise<Type>;
-}
-interface IMangoMigrationType {
-    name: string;
-    timestamp: number;
-    up: (mango: Mango) => Promise<void>;
-    down: (mango: Mango) => Promise<void>;
-}
-declare class MangoMigration {
-    private mango;
-    private mango_migration_table_name;
-    private migrations;
-    initialize(): Promise<void>;
-    constructor(mango: Mango);
-    addOneMigrationToDB(migration: IMangoMigrationType): Promise<void>;
-    addManyMigrationToDB(migration: IMangoMigrationType[]): Promise<void>;
-    deleteOneMigrationFromDB(migration: IMangoMigrationType): Promise<void>;
-    deleteManyMigrationFromDB(migrations: IMangoMigrationType[]): Promise<void>;
-    add(migration: IMangoMigrationType): MangoMigration;
-    getExecutedMigrations(): Promise<string[]>;
-    migrateUp(): Promise<void>;
-    migrateUpToLatest(): Promise<void>;
-    migrateDown(): Promise<void>;
-    migrateDownToOldest(): Promise<void>;
-    status(): Promise<void>;
-}
-export { Mango, MangoType, MangoTable };
-export { MangoMigration, IMangoMigrationType };