@inflector/optima 1.0.0 → 1.0.1

package/dist/Qfluent.d.ts

@@ -0,0 +1,40 @@
+import type { Infer } from "./schema";
+import type { Extension, OptimaTable, Where } from "./table";
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type SetFlag<State, Key extends keyof State> = {
+    [P in keyof State]: P extends Key ? true : State[P];
+};
+export type MapToFalse<T> = {
+    [K in keyof T]: false;
+};
+export type InitialState<T> = {
+    [K in keyof T]: false;
+} & {
+    extended: false;
+};
+export type QueryMethods<TDef extends Record<string, any>> = {
+    limit: [n: number];
+    offset: [n: number];
+    orderBy: [col: keyof TDef | Array<keyof TDef>, dir?: "ASC" | "DESC"];
+    where: [w: Where<Infer<TDef>>];
+};
+export type QueryOneMethods<TDef extends Record<string, any>> = {
+    where: [w: Where<Infer<TDef>>];
+};
+export type FluentQueryBuilder<TDef extends Record<string, any>, Result, State extends Record<keyof QueryMethods<TDef> | "extended", boolean>> = {
+    [K in keyof QueryMethods<TDef> as State[K] extends true ? never : K]: (...args: QueryMethods<TDef>[K]) => FluentQueryBuilder<TDef, Result, SetFlag<State, K>>;
+} & {
+    [K in "extend" as State["extended"] extends true ? never : K]: <ExtTable extends OptimaTable<any>>(table: ExtTable) => FluentQueryBuilder<TDef, Prettify<Result & Extension<TDef, ExtTable>>, SetFlag<State, "extended">>;
+} & PromiseLike<Result[]>;
+export type FluentQueryBuilderOne<TDef extends Record<string, any>, Result, State extends Record<keyof QueryOneMethods<TDef> | "extended", boolean>> = {
+    [K in keyof QueryOneMethods<TDef> as State[K] extends true ? never : K]: (...args: QueryOneMethods<TDef>[K]) => FluentQueryBuilderOne<TDef, Result, SetFlag<State, K>>;
+} & {
+    [K in "extend" as State["extended"] extends true ? never : K]: <ExtTable extends OptimaTable<any>>(table: ExtTable) => FluentQueryBuilderOne<TDef, Prettify<Result & Extension<TDef, ExtTable>>, SetFlag<State, "extended">>;
+} & PromiseLike<Result | undefined>;
+export declare const createProxyHandler: (table: OptimaTable<any>, config: any, isSingleResult: boolean) => {
+    get(target: any, prop: string | symbol): (...args: any[]) => any;
+};
+export declare function createQueryBuilder<TDef extends Record<string, any>, Result>(table: OptimaTable<TDef>, initialConfig?: any): FluentQueryBuilder<TDef, Result, InitialState<QueryMethods<TDef>>>;
+export declare function createQueryBuilderOne<TDef extends Record<string, any>, Result>(table: OptimaTable<TDef>, initialConfig?: any): FluentQueryBuilderOne<TDef, Result, InitialState<QueryOneMethods<TDef>>>;

package/dist/Qfluent.js

@@ -0,0 +1,64 @@
+// --- Implementation ---
+export const createProxyHandler = (table, config, isSingleResult) => {
+    return {
+        get(target, prop) {
+            // 1. Handle Promise Execution (.then)
+            if (prop === "then") {
+                return async (resolve, reject) => {
+                    const tableAny = table;
+                    try {
+                        const { sql } = tableAny.BuildSelect(tableAny["Name"], config);
+                        const rawResult = await (await tableAny.Connection.run(sql)).getRowObjects();
+                        const formatted = tableAny.FormatOut(rawResult);
+                        if (isSingleResult) {
+                            const val = formatted.length > 0 ? formatted[0] : undefined;
+                            resolve(val);
+                        }
+                        else {
+                            resolve(formatted);
+                        }
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                };
+            }
+            // 2. Handle 'extend'
+            if (prop === "extend") {
+                return (extTable) => {
+                    config.extend = config.extend || [];
+                    // Optional Runtime Safety: Prevent adding the exact same table instance twice
+                    // (Even though types now prevent calling extend() twice on the same chain)
+                    if (!config.extend.includes(extTable)) {
+                        config.extend.push(extTable);
+                    }
+                    return new Proxy(target, createProxyHandler(table, config, isSingleResult));
+                };
+            }
+            // 3. Handle Standard Schema Methods
+            return (...args) => {
+                if (args.length === 1) {
+                    config[prop] = args[0];
+                }
+                else if (args.length > 1) {
+                    config[prop] = args;
+                }
+                else {
+                    config[prop] = true;
+                }
+                return new Proxy(target, createProxyHandler(table, config, isSingleResult));
+            };
+        },
+    };
+};
+// --- Factory Functions ---
+export function createQueryBuilder(table, initialConfig = {}) {
+    const dummyState = {};
+    // The InitialState type ensures 'extended' starts as false
+    return new Proxy(dummyState, createProxyHandler(table, initialConfig, false));
+}
+export function createQueryBuilderOne(table, initialConfig = {}) {
+    const config = { ...initialConfig, limit: 1 };
+    const dummyState = {};
+    return new Proxy(dummyState, createProxyHandler(table, config, true));
+}

package/dist/database.d.ts

@@ -0,0 +1,32 @@
+import { DuckDBConnection, DuckDBInstance } from "@duckdb/node-api";
+import { OptimaTable } from "./table";
+type DBRow = Record<string, unknown>;
+type SchemaConfig = Record<string, any>;
+export declare class OptimaDB<T extends Record<string, OptimaTable>> {
+    private instance;
+    private connection;
+    Tables: T;
+    constructor(instance: DuckDBInstance, connection: DuckDBConnection, tables: T);
+    /**
+     * Initializes the database, connects, detects schema changes,
+     * runs migrations, and returns the DB instance.
+     */
+    static Open<TSchema extends SchemaConfig>(name: string, schema: TSchema, options?: {
+        MemoryLimit?: string;
+        ThreadCount?: number;
+    }): Promise<OptimaDB<{
+        [K in keyof TSchema]: OptimaTable<TSchema[K]>;
+    }>>;
+    /**
+     * Executes a raw SQL query and returns rows as objects.
+     */
+    execute(sql: string): Promise<DBRow[]>;
+    getTables(): Promise<string[]>;
+    getDiskSize(): Promise<unknown>;
+    /**
+     * Runs a function within a transaction.
+     * Re-throws error after rollback so caller handles logic failure.
+     */
+    transaction<R>(fn: () => Promise<R>): Promise<R>;
+}
+export {};

package/dist/database.js

@@ -0,0 +1,240 @@
+import { DuckDBInstance } from "@duckdb/node-api";
+import { OptimaTable } from "./table";
+export class OptimaDB {
+    constructor(instance, connection, tables) {
+        this.instance = instance;
+        this.connection = connection;
+        this.Tables = tables;
+    }
+    /**
+     * Initializes the database, connects, detects schema changes,
+     * runs migrations, and returns the DB instance.
+     */
+    static async Open(name = ":memory:", schema, options) {
+        const instance = await DuckDBInstance.create(name);
+        const connection = await instance.connect();
+        // 1. Apply Options
+        if (options?.MemoryLimit) {
+            await connection.run(`SET memory_limit = '${options.MemoryLimit}';`);
+        }
+        if (options?.ThreadCount) {
+            await connection.run(`SET threads = ${options.ThreadCount};`);
+        }
+        // 2. Auto-Migration
+        const existingTables = await (await connection.run(`SELECT * from duckdb_tables`)).getRowObjects();
+        const cleanSchema = SchemaMigrator.transformSchema(schema);
+        const migrationSQL = SchemaMigrator.generateSQL(existingTables, cleanSchema);
+        if (migrationSQL.length > 0) {
+            console.log(`[OptimaDB] Applying ${migrationSQL.length} migrations...`);
+            // Run migrations in a transaction to ensure safety
+            await connection.run("BEGIN TRANSACTION;");
+            try {
+                for (const sql of migrationSQL) {
+                    await connection.run(sql);
+                }
+                await connection.run("COMMIT;");
+            }
+            catch (err) {
+                await connection.run("ROLLBACK;");
+                console.error("[OptimaDB] Migration failed, rolling back.", err);
+                throw err;
+            }
+        }
+        // 3. Initialize Table Wrappers
+        const tables = {};
+        for (const key of Object.keys(schema)) {
+            tables[key] = await OptimaTable.create(key, schema[key], connection);
+        }
+        return new OptimaDB(instance, connection, tables);
+    }
+    /**
+     * Executes a raw SQL query and returns rows as objects.
+     */
+    async execute(sql) {
+        return (await this.connection.run(sql)).getRowObjects();
+    }
+    async getTables() {
+        const result = await this.execute("PRAGMA show_tables;");
+        return result.map((t) => t.name);
+    }
+    async getDiskSize() {
+        const result = await this.execute("PRAGMA database_size;");
+        return result[0];
+    }
+    /**
+     * Runs a function within a transaction.
+     * Re-throws error after rollback so caller handles logic failure.
+     */
+    async transaction(fn) {
+        await this.connection.run("BEGIN TRANSACTION;");
+        try {
+            const result = await fn();
+            await this.connection.run("COMMIT;");
+            return result;
+        }
+        catch (e) {
+            await this.connection.run("ROLLBACK;");
+            throw e;
+        }
+    }
+}
+/**
+ * ------------------------------------------------------------------
+ * INTERNAL MIGRATION LOGIC
+ * Encapsulated to keep the main class clean.
+ * ------------------------------------------------------------------
+ */
+class SchemaMigrator {
+    /**
+     * Transforms the complex Module/ColumnImpl schema into a simple config object.
+     */
+    static transformSchema(schemaObject) {
+        const cleanSchema = {};
+        for (const [tableName, tableDef] of Object.entries(schemaObject)) {
+            if (typeof tableDef !== "object" || tableDef === null)
+                continue;
+            const realTableName = tableDef.__tableName || tableName;
+            cleanSchema[realTableName] = {};
+            for (const [colName, colImpl] of Object.entries(tableDef)) {
+                if (colName.startsWith("__"))
+                    continue; // Skip metadata
+                // @ts-ignore - Assuming colImpl structure based on input
+                if (colImpl?.config) {
+                    // @ts-ignore
+                    const config = { ...colImpl.config };
+                    // Handle STRUCT merging
+                    if (config.SQlType === "STRUCT" && config.STRUCTType) {
+                        config.SQlType = config.STRUCTType;
+                    }
+                    cleanSchema[realTableName][colName] = config;
+                }
+            }
+        }
+        return cleanSchema;
+    }
+    /**
+     * Generates SQL statements to migrate DB from Current -> Desired state.
+     */
+    static generateSQL(existingTablesRaw, desiredSchema) {
+        const currentSchema = this.parseDuckDBTableSQL(existingTablesRaw);
+        const steps = [];
+        for (const [tableName, fields] of Object.entries(desiredSchema)) {
+            // 1. CREATE TABLE
+            if (!currentSchema[tableName]) {
+                const fieldDefs = Object.entries(fields).map(([colName, config]) => {
+                    let def = `"${colName}" ${config.SQlType}`;
+                    if (config.primaryKey)
+                        def += " PRIMARY KEY";
+                    if (config.notnull)
+                        def += " NOT NULL";
+                    return def;
+                });
+                steps.push(`CREATE TABLE ${tableName} (${fieldDefs.join(", ")});`);
+                continue;
+            }
+            const currentTableCols = currentSchema[tableName];
+            for (const [colName, config] of Object.entries(fields)) {
+                // 2. ADD COLUMN
+                if (!currentTableCols[colName]) {
+                    let def = `${config.SQlType}`;
+                    // If adding NOT NULL to existing table, we need a default value
+                    if (config.notnull) {
+                        def += ` DEFAULT ${this.getDefaultValueForType(config.SQlType)}`;
+                    }
+                    steps.push(`ALTER TABLE ${tableName} ADD COLUMN "${colName}" ${def};`);
+                    // Enforce strict constraint after adding (if supported by version, else implied by definition)
+                    if (config.notnull) {
+                        steps.push(`ALTER TABLE ${tableName} ALTER "${colName}" SET NOT NULL;`);
+                    }
+                    continue;
+                }
+                // 3. ALTER COLUMN (Type or Constraints)
+                const currentCol = currentTableCols[colName];
+                const normCurrentType = currentCol.type.replace(/\s+/g, "").toUpperCase();
+                const normNewType = config.SQlType.replace(/\s+/g, "").toUpperCase();
+                // 3a. Type Mismatch
+                // We skip complex struct comparison here to avoid false positives on spacing
+                if (normCurrentType !== normNewType && !normNewType.startsWith("STRUCT")) {
+                    steps.push(`ALTER TABLE ${tableName} ALTER "${colName}" TYPE ${config.SQlType};`);
+                }
+                // 3b. Not Null Mismatch
+                const desiredNotNull = !!config.notnull;
+                if (desiredNotNull !== currentCol.isNotNull) {
+                    if (desiredNotNull) {
+                        steps.push(`ALTER TABLE ${tableName} ALTER "${colName}" SET NOT NULL;`);
+                    }
+                    else {
+                        steps.push(`ALTER TABLE ${tableName} ALTER "${colName}" DROP NOT NULL;`);
+                    }
+                }
+            }
+        }
+        return steps;
+    }
+    /**
+     * Parses raw "CREATE TABLE" SQL from DuckDB into a usable map.
+     */
+    static parseDuckDBTableSQL(existingTables) {
+        const schemaMap = {};
+        existingTables.forEach((table) => {
+            const match = table.sql.match(/CREATE TABLE "?\w+"?\s*\((.*)\);/s);
+            if (!match)
+                return;
+            const columnBody = match[1];
+            const columns = {};
+            let depth = 0;
+            let currentChunk = "";
+            for (let i = 0; i < columnBody.length; i++) {
+                const char = columnBody[i];
+                if (char === "(")
+                    depth++;
+                if (char === ")")
+                    depth--;
+                if (char === "," && depth === 0) {
+                    this.processColumnLine(currentChunk, columns);
+                    currentChunk = "";
+                }
+                else {
+                    currentChunk += char;
+                }
+            }
+            if (currentChunk.trim())
+                this.processColumnLine(currentChunk, columns);
+            schemaMap[table.table_name] = columns;
+        });
+        return schemaMap;
+    }
+    static processColumnLine(line, columnMap) {
+        const parts = line.trim().match(/^("?[\w]+"?)\s+(.*)$/);
+        if (!parts)
+            return;
+        const name = parts[1]?.replace(/"/g, "");
+        const definition = parts[2];
+        const upDef = definition?.toUpperCase();
+        let type = definition?.split(" ")[0];
+        if (upDef?.startsWith("STRUCT")) {
+            type = definition; // Simplification: capture full struct definition
+        }
+        if (name !== undefined) {
+            columnMap[name] = {
+                type: type,
+                isNotNull: upDef?.includes("NOT NULL") ?? false,
+                isPrimaryKey: upDef?.includes("PRIMARY KEY") ?? false,
+            };
+        }
+    }
+    /**
+     * Returns a safe default value for a given SQL type.
+     * Required when adding NOT NULL columns to existing tables.
+     */
+    static getDefaultValueForType(type) {
+        const t = type.toUpperCase();
+        if (t.includes("INT") || t.includes("FLOAT") || t.includes("DECIMAL") || t.includes("DOUBLE"))
+            return "0";
+        if (t.includes("BOOL"))
+            return "FALSE";
+        if (t.includes("STRUCT") || t.includes("MAP") || t.includes("LIST"))
+            return "NULL"; // Complex types usually default to NULL
+        return "''"; // VARCHAR, TEXT, etc.
+    }
+}

package/dist/fluent.d.ts

@@ -0,0 +1,13 @@
+export type SetFlag<State, Key extends keyof State> = {
+    [P in keyof State]: P extends Key ? true : State[P];
+};
+type MapToFalse<T> = {
+    [K in keyof T]: false;
+};
+type FluentStep<Schema, State extends {
+    [K in keyof Schema]: boolean | unknown;
+}, Result> = {
+    [K in keyof Schema as State[K] extends true ? never : K]: Schema[K] extends boolean ? () => FluentStep<Schema, SetFlag<State, K>, Result> : Schema[K] extends any[] ? (...args: Schema[K]) => FluentStep<Schema, SetFlag<State, K>, Result> : (arg: Schema[K]) => FluentStep<Schema, SetFlag<State, K>, Result>;
+} & PromiseLike<Result>;
+export declare function createFluentBuilder<Schema, R = Schema>(onBuild?: (data: Schema) => R | Promise<R>): FluentStep<Schema, MapToFalse<Schema>, R>;
+export {};

package/dist/fluent.js

@@ -0,0 +1,29 @@
+export function createFluentBuilder(onBuild) {
+    const data = {};
+    const handler = {
+        get(target, prop) {
+            if (prop === "then") {
+                return (resolve, reject) => {
+                    const result = onBuild ? onBuild(target) : target;
+                    Promise.resolve(result).then(resolve, reject);
+                };
+            }
+            return (...args) => {
+                // 1. No Args -> True (Flag)
+                if (args.length === 0) {
+                    target[prop] = true;
+                }
+                // 2. One Arg -> Store value
+                else if (args.length === 1) {
+                    target[prop] = args[0];
+                }
+                // 3. Multiple Args -> Store as Array/Tuple
+                else {
+                    target[prop] = args;
+                }
+                return new Proxy(target, handler);
+            };
+        },
+    };
+    return new Proxy(data, handler);
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./database";
+export * from "./schema";
+export { eq, ne, gt, gte, lt, lte, inOp, notIn, between, notBetween, is, isNot, like, notLike, startsWith, endsWith, contains, regexp, notRegexp, cond, type ConditionBuilder } from "./table";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./database";
+export * from "./schema";
+export { eq, ne, gt, gte, lt, lte, inOp, notIn, between, notBetween, is, isNot, like, notLike, startsWith, endsWith, contains, regexp, notRegexp, cond } from "./table";

package/dist/schema.d.ts

@@ -0,0 +1,85 @@
+import * as z from "zod";
+type SetFlag<C extends ColumnConfig, K extends keyof ColumnConfig> = Omit<C, K> & {
+    [P in K]: true;
+};
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type Restrict<K extends keyof ColumnConfig> = {
+    [P in keyof ColumnConfig]: P extends K ? true : false;
+};
+export type One<T> = T & {
+    readonly __refKind: "one";
+};
+export type Many<T> = T & {
+    readonly __refKind: "many";
+};
+export declare const refHelpers: {
+    one: <T>(ref: T) => One<T>;
+    many: <T>(ref: T) => Many<T>;
+};
+export type InferColumnType<T> = T extends ColumnBuilder<infer U, any, any> ? U : never;
+export type Infer<T extends Record<string, any>> = Prettify<{
+    [K in keyof T as K extends `__${string}` ? never : T[K] extends ColumnBuilder<any, infer C, any> ? C["notnull"] extends true ? K : never : never]: T[K] extends ColumnBuilder<infer U, any, any> ? U : never;
+} & // 2. Handle Optional Keys (notnull: false)
+{
+    [K in keyof T as K extends `__${string}` ? never : T[K] extends ColumnBuilder<any, infer C, any> ? C["notnull"] extends true ? never : K : never]: T[K] extends ColumnBuilder<infer U, any, any> ? U | null : never;
+}>;
+export type InferAdd<T extends Record<string, any>> = Prettify<{
+    [K in keyof T as K extends `__${string}` ? never : T[K] extends ColumnBuilder<any, infer C, any> ? C["notnull"] extends true ? K : never : never]: T[K] extends ColumnBuilder<infer U, any, any> ? U : never;
+} & // 2. Handle Optional Keys (notnull: false)
+{
+    [K in keyof T as K extends `__${string}` ? never : T[K] extends ColumnBuilder<any, infer C, any> ? C["notnull"] extends true ? never : K : never]?: T[K] extends ColumnBuilder<infer U, any, any> ? U | null : never;
+}>;
+export type ColumnConfig = {
+    SQlType: boolean;
+    primaryKey: boolean;
+    notnull: boolean;
+    unique: boolean;
+    default: boolean;
+    defaultNow: boolean;
+    reference: boolean;
+    validate: boolean;
+    transform: boolean;
+    deprecated: boolean;
+    STRUCTType: boolean;
+};
+export type ColumnBuilder<Type, Config extends ColumnConfig, RefSchema = never> = {
+    [K in keyof ColumnConfig as K extends "STRUCTType" ? never : Config[K] extends true ? never : K]: K extends "SQlType" ? (val: string) => ColumnBuilder<Type, SetFlag<Config, "SQlType">, RefSchema> : K extends "primaryKey" ? () => ColumnBuilder<Type, SetFlag<Config, "primaryKey">, RefSchema> : K extends "notnull" ? () => ColumnBuilder<Type, SetFlag<Config, "notnull">, RefSchema> : K extends "unique" ? () => ColumnBuilder<Type, SetFlag<Config, "unique">, RefSchema> : K extends "default" ? (val: Type | (() => Type)) => ColumnBuilder<Type, SetFlag<Config, "default">, RefSchema> : K extends "defaultNow" ? () => ColumnBuilder<Type, SetFlag<Config, "defaultNow">, RefSchema> : K extends "reference" ? <TRef>(ref: (helpers: typeof refHelpers) => TRef) => ColumnBuilder<Type, SetFlag<Config, "reference">, TRef> : K extends "validate" ? (fn: (val: Type) => boolean) => ColumnBuilder<Type, SetFlag<Config, "validate">, RefSchema> : K extends "transform" ? (fn: (val: Type) => Type) => ColumnBuilder<Type, SetFlag<Config, "transform">, RefSchema> : K extends "deprecated" ? () => ColumnBuilder<Type, SetFlag<Config, "deprecated">, RefSchema> : never;
+};
+export declare const Int: () => ColumnBuilder<number, SetFlag<Restrict<"defaultNow">, "SQlType">, never>;
+export declare const BigInt: () => ColumnBuilder<bigint, SetFlag<Restrict<"defaultNow">, "SQlType">, never>;
+export declare const Float: () => ColumnBuilder<number, SetFlag<Restrict<"defaultNow">, "SQlType">, never>;
+export declare const Boolean: () => ColumnBuilder<boolean, SetFlag<Restrict<"primaryKey" | "unique" | "defaultNow">, "SQlType">, never>;
+export declare const Text: () => ColumnBuilder<string, SetFlag<Restrict<"defaultNow">, "SQlType">, never>;
+export declare const Uuid: () => ColumnBuilder<string, SetFlag<Restrict<"defaultNow">, "SQlType">, never>;
+export declare const DateType: () => ColumnBuilder<Date, SetFlag<Restrict<"default">, "SQlType">, never>;
+export declare const Timestamp: () => ColumnBuilder<Date, SetFlag<Restrict<"default">, "SQlType">, never>;
+export declare const Enum: <T extends string | number>(vals: readonly T[]) => ColumnBuilder<T, SetFlag<SetFlag<Restrict<"defaultNow">, "validate">, "SQlType">, never>;
+export * from "zod";
+export declare const Json: <T extends z.ZodRawShape>(obj: T) => ColumnBuilder<z.core.$InferObjectOutput<T, {}>, SetFlag<Restrict<"primaryKey" | "unique" | "defaultNow">, "SQlType">, never>;
+export declare const Array: <T extends z.ZodTypeAny>(schema: T) => ColumnBuilder<z.core.output<T>[], SetFlag<Restrict<"primaryKey" | "unique" | "defaultNow">, "SQlType">, never>;
+export declare const Email: () => ColumnBuilder<string, SetFlag<SetFlag<Restrict<"defaultNow">, "SQlType">, "validate">, never>;
+export declare const Slug: () => ColumnBuilder<string, SetFlag<SetFlag<Restrict<"defaultNow">, "SQlType">, "validate">, never>;
+export declare const Color: () => ColumnBuilder<string, SetFlag<SetFlag<Restrict<"defaultNow">, "SQlType">, "validate">, never>;
+export declare const Bytes: () => ColumnBuilder<Uint8Array<ArrayBufferLike>, SetFlag<Restrict<"primaryKey" | "defaultNow">, "SQlType">, never>;
+export declare const Password: () => ColumnBuilder<string, SetFlag<Restrict<"primaryKey" | "unique" | "defaultNow">, "SQlType">, never>;
+export declare const GeoPoint: () => ColumnBuilder<{
+    latitude: number;
+    longitude: number;
+}, SetFlag<Restrict<"primaryKey" | "defaultNow">, "SQlType">, never>;
+export declare const GeoArea: () => ColumnBuilder<{
+    latitude: number;
+    longitude: number;
+    radius: number;
+}, SetFlag<Restrict<"primaryKey" | "defaultNow">, "SQlType">, never>;
+export declare const Table: <Name extends string, T extends Record<string, ColumnBuilder<any, any>>>(name: Name, fields: T) => T & {
+    __tableName: Name;
+};
+export declare class SQLBuilder {
+    static BuildField(name: string, f: ColumnBuilder<any, any>): {
+        sql: string;
+        ref: boolean;
+    };
+    static BuildTable(name: string, t: Record<string, any>): string;
+}