noormme 1.0.0

package/dist/cjs/noormme.js

@@ -0,0 +1,521 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOORMME = void 0;
+const schema_discovery_js_1 = require("./schema/schema-discovery.js");
+const type_generator_js_1 = require("./types/type-generator.js");
+const repository_factory_js_1 = require("./repository/repository-factory.js");
+const relationship_engine_js_1 = require("./relationships/relationship-engine.js");
+const cache_manager_js_1 = require("./cache/cache-manager.js");
+const logger_js_1 = require("./logging/logger.js");
+const NoormError_js_1 = require("./errors/NoormError.js");
+const dotenv_1 = require("dotenv");
+const schema_watcher_js_1 = require("./watch/schema-watcher.js");
+const query_analyzer_js_1 = require("./performance/query-analyzer.js");
+const sqlite_auto_optimizer_js_1 = require("./dialect/sqlite/sqlite-auto-optimizer.js");
+const sqlite_auto_indexer_js_1 = require("./dialect/sqlite/sqlite-auto-indexer.js");
+// Global initialization lock to prevent concurrent initialization
+const globalInitLock = new Map();
+/**
+ * NOORMME - No ORM, just magic!
+ * Zero-configuration pseudo-ORM that works with any existing database
+ */
+class NOORMME {
+    db;
+    config;
+    dialect;
+    schemaDiscovery;
+    typeGenerator;
+    repositoryFactory;
+    relationshipEngine;
+    cacheManager;
+    logger;
+    schemaWatcher = null;
+    queryAnalyzer = null;
+    sqliteAutoOptimizer = null;
+    sqliteAutoIndexer = null;
+    initialized = false;
+    repositories = new Map();
+    instanceId;
+    constructor(configOrConnectionString) {
+        // Load .env if it exists
+        (0, dotenv_1.config)({ path: '.env' });
+        // Handle different constructor signatures
+        let config;
+        if (!configOrConnectionString) {
+            // Try to read from environment
+            const databaseUrl = process.env.DATABASE_URL;
+            if (!databaseUrl) {
+                throw new NoormError_js_1.NoormError('No database configuration provided', {
+                    operation: 'initialization',
+                    suggestion: 'Either pass a connection string or set DATABASE_URL in .env',
+                });
+            }
+            config = this.parseConnectionString(databaseUrl);
+        }
+        else if (typeof configOrConnectionString === 'string') {
+            config = this.parseConnectionString(configOrConnectionString);
+        }
+        else {
+            config = configOrConnectionString;
+        }
+        this.config = this.mergeConfig(config);
+        this.logger = new logger_js_1.Logger(this.config.logging);
+        this.cacheManager = new cache_manager_js_1.CacheManager(this.config.cache);
+        // Generate unique instance ID for this NOORMME instance
+        this.instanceId = `${this.config.dialect}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        // Initialize Kysely with the provided dialect
+        this.dialect = this.createDialect();
+        this.db = new (require('./kysely.js').Kysely)({
+            dialect: this.dialect,
+            log: this.config.logging?.enabled ? this.logger.createKyselyLogger() : undefined
+        });
+        // Initialize core components
+        this.schemaDiscovery = new schema_discovery_js_1.SchemaDiscovery(this.db, this.config.introspection, this.dialect);
+        this.typeGenerator = new type_generator_js_1.TypeGenerator(this.config.introspection);
+        this.repositoryFactory = new repository_factory_js_1.RepositoryFactory(this.db, this.config.performance);
+        this.relationshipEngine = new relationship_engine_js_1.RelationshipEngine(this.db, this.config.performance);
+    }
+    /**
+     * Initialize NOORMME - discovers schema and generates types
+     */
+    async initialize() {
+        if (this.initialized) {
+            this.logger.warn('NOORMME already initialized');
+            return;
+        }
+        // Check if another instance is already initializing the same database
+        const lockKey = `${this.config.dialect}-${this.config.connection.database || 'default'}`;
+        if (globalInitLock.has(lockKey)) {
+            this.logger.info(`Waiting for another instance to finish initializing ${lockKey}...`);
+            await globalInitLock.get(lockKey);
+            // Check again after waiting
+            if (this.initialized) {
+                this.logger.warn('NOORMME already initialized after waiting');
+                return;
+            }
+        }
+        // Create initialization promise and store it
+        const initPromise = this._doInitialize();
+        globalInitLock.set(lockKey, initPromise);
+        try {
+            await initPromise;
+        }
+        finally {
+            // Clean up the lock
+            globalInitLock.delete(lockKey);
+        }
+    }
+    async _doInitialize() {
+        try {
+            this.logger.info('Initializing NOORMME...');
+            // Test database connection using the dialect-specific introspector
+            const introspector = this.dialect.createIntrospector(this.db);
+            await introspector.getTables();
+            this.logger.info('Database connection successful');
+            // Discover schema
+            this.logger.info('Discovering database schema...');
+            const schemaInfo = await this.schemaDiscovery.discoverSchema();
+            this.logger.info(`Discovered ${schemaInfo.tables.length} tables`);
+            // Generate types
+            this.logger.info('Generating TypeScript types...');
+            const generatedTypes = this.typeGenerator.generateTypes(schemaInfo);
+            this.logger.info(`Generated types for ${generatedTypes.entities.length} entities`);
+            // Cache schema and types
+            await this.cacheManager.set('schema', schemaInfo);
+            await this.cacheManager.set('types', generatedTypes);
+            // Initialize relationship engine
+            this.relationshipEngine.initialize(schemaInfo.relationships);
+            // Initialize query analyzer for development mode
+            this.queryAnalyzer = new query_analyzer_js_1.QueryAnalyzer(this.db, this.logger, schemaInfo, {
+                enabled: this.config.performance?.enableQueryOptimization ?? true,
+                slowQueryThreshold: 1000,
+                missingIndexDetection: true,
+                largeResultSetThreshold: 1000
+            });
+            // Initialize SQLite-specific auto-optimization features
+            if (this.config.dialect === 'sqlite') {
+                this.sqliteAutoOptimizer = sqlite_auto_optimizer_js_1.SQLiteAutoOptimizer.getInstance(this.logger);
+                this.sqliteAutoIndexer = sqlite_auto_indexer_js_1.SQLiteAutoIndexer.getInstance(this.logger);
+                // Apply automatic optimizations if enabled (default: true)
+                const enableAutoOptimization = this.config.performance?.enableAutoOptimization !== false;
+                if (enableAutoOptimization) {
+                    await this.applySQLiteAutoOptimizations();
+                }
+            }
+            this.initialized = true;
+            this.logger.info('NOORMME initialized successfully!');
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize NOORMME:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if NOORMME is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Apply SQLite auto-optimizations
+     */
+    async applySQLiteAutoOptimizations() {
+        if (!this.sqliteAutoOptimizer)
+            return;
+        try {
+            this.logger.info('Applying SQLite auto-optimizations...');
+            const config = this.sqliteAutoOptimizer.getDefaultConfig();
+            const result = await this.sqliteAutoOptimizer.optimizeDatabase(this.db, config);
+            if (result.appliedOptimizations.length > 0) {
+                this.logger.info(`Applied ${result.appliedOptimizations.length} SQLite optimizations`);
+                result.appliedOptimizations.forEach(opt => this.logger.debug(`  ✓ ${opt}`));
+            }
+            if (result.recommendations.length > 0) {
+                this.logger.info(`Generated ${result.recommendations.length} recommendations`);
+                result.recommendations.forEach(rec => this.logger.debug(`  💡 ${rec}`));
+            }
+            if (result.warnings.length > 0) {
+                this.logger.warn(`Found ${result.warnings.length} warnings`);
+                result.warnings.forEach(warning => this.logger.warn(`  ⚠️ ${warning}`));
+            }
+        }
+        catch (error) {
+            this.logger.warn('Failed to apply SQLite auto-optimizations:', error);
+        }
+    }
+    /**
+     * Get SQLite optimization recommendations
+     */
+    async getSQLiteOptimizations() {
+        if (this.config.dialect !== 'sqlite' || !this.sqliteAutoOptimizer) {
+            throw new NoormError_js_1.NoormError('SQLite optimizations are only available for SQLite databases');
+        }
+        const config = this.sqliteAutoOptimizer.getDefaultConfig();
+        return await this.sqliteAutoOptimizer.optimizeDatabase(this.db, config);
+    }
+    /**
+     * Get SQLite index recommendations
+     */
+    async getSQLiteIndexRecommendations(options) {
+        if (this.config.dialect !== 'sqlite' || !this.sqliteAutoIndexer) {
+            throw new NoormError_js_1.NoormError('SQLite index recommendations are only available for SQLite databases');
+        }
+        return await this.sqliteAutoIndexer.analyzeAndRecommend(this.db, options);
+    }
+    /**
+     * Record query for SQLite auto-indexing analysis
+     */
+    recordQuery(query, executionTime, table) {
+        if (this.config.dialect === 'sqlite' && this.sqliteAutoIndexer) {
+            this.sqliteAutoIndexer.recordQuery(query, executionTime, table);
+        }
+        if (this.queryAnalyzer) {
+            this.queryAnalyzer.recordQuery(query, executionTime, undefined, table);
+        }
+    }
+    /**
+     * Get SQLite performance metrics
+     */
+    async getSQLitePerformanceMetrics() {
+        if (this.config.dialect !== 'sqlite' || !this.sqliteAutoOptimizer) {
+            throw new NoormError_js_1.NoormError('SQLite performance metrics are only available for SQLite databases');
+        }
+        return await this.sqliteAutoOptimizer.analyzeDatabase(this.db);
+    }
+    /**
+     * Get SQLite backup recommendations
+     */
+    async getSQLiteBackupRecommendations() {
+        if (this.config.dialect !== 'sqlite' || !this.sqliteAutoOptimizer) {
+            throw new NoormError_js_1.NoormError('SQLite backup recommendations are only available for SQLite databases');
+        }
+        return await this.sqliteAutoOptimizer.getBackupRecommendations(this.db);
+    }
+    /**
+     * Get a repository for the specified table
+     */
+    getRepository(tableName) {
+        if (!this.initialized) {
+            throw new Error('NOORMME must be initialized before getting repositories. Call await db.initialize() first.');
+        }
+        if (this.repositories.has(tableName)) {
+            return this.repositories.get(tableName);
+        }
+        const schemaInfo = this.cacheManager.get('schema');
+        if (!schemaInfo) {
+            throw new Error('Schema not found. Please reinitialize NOORMME.');
+        }
+        const table = schemaInfo.tables.find(t => t.name === tableName);
+        if (!table) {
+            throw new Error(`Table '${tableName}' not found in schema. Available tables: ${schemaInfo.tables.map(t => t.name).join(', ')}`);
+        }
+        const repository = this.repositoryFactory.createRepository(table, schemaInfo.relationships);
+        this.repositories.set(tableName, repository);
+        return repository;
+    }
+    /**
+     * Get schema information
+     */
+    async getSchemaInfo() {
+        if (!this.initialized) {
+            throw new Error('NOORMME must be initialized first');
+        }
+        const cached = this.cacheManager.get('schema');
+        if (cached) {
+            return cached;
+        }
+        // Re-discover schema if not cached
+        return await this.schemaDiscovery.discoverSchema();
+    }
+    /**
+     * Refresh schema (useful when database structure changes)
+     */
+    async refreshSchema() {
+        this.logger.info('Refreshing schema...');
+        const schemaInfo = await this.schemaDiscovery.discoverSchema();
+        const generatedTypes = this.typeGenerator.generateTypes(schemaInfo);
+        // Update cache
+        await this.cacheManager.set('schema', schemaInfo);
+        await this.cacheManager.set('types', generatedTypes);
+        // Clear existing repositories
+        this.repositories.clear();
+        // Reinitialize relationship engine
+        this.relationshipEngine.initialize(schemaInfo.relationships);
+        this.logger.info('Schema refreshed successfully');
+        return schemaInfo;
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(updates) {
+        this.config = this.mergeConfig({ ...this.config, ...updates });
+        // Update components with new config
+        if (this.config.logging) {
+            this.logger.updateConfig(this.config.logging);
+        }
+        if (this.config.cache) {
+            this.cacheManager.updateConfig(this.config.cache);
+        }
+        this.logger.info('Configuration updated');
+    }
+    /**
+     * Start monitoring schema changes in development mode
+     */
+    startSchemaWatching(options) {
+        if (!this.initialized) {
+            throw new NoormError_js_1.NoormError('NOORMME must be initialized before starting schema watching');
+        }
+        if (!this.schemaWatcher) {
+            this.schemaWatcher = new schema_watcher_js_1.SchemaWatcher(this.db, this.schemaDiscovery, this.logger, options);
+            // Auto-refresh schema when changes detected
+            this.schemaWatcher.onSchemaChange(async (changes) => {
+                this.logger.info(`Schema changes detected: ${changes.length} changes`);
+                changes.forEach(change => {
+                    this.logger.info(`  - ${change.type}: ${change.table}`);
+                });
+                try {
+                    await this.refreshSchema();
+                    this.logger.info('Schema refreshed successfully');
+                }
+                catch (error) {
+                    this.logger.error('Failed to refresh schema:', error);
+                }
+            });
+        }
+        this.schemaWatcher.startWatching();
+    }
+    /**
+     * Stop monitoring schema changes
+     */
+    stopSchemaWatching() {
+        if (this.schemaWatcher) {
+            this.schemaWatcher.stopWatching();
+        }
+    }
+    /**
+     * Register callback for schema changes
+     */
+    onSchemaChange(callback) {
+        if (!this.schemaWatcher) {
+            this.schemaWatcher = new schema_watcher_js_1.SchemaWatcher(this.db, this.schemaDiscovery, this.logger);
+        }
+        this.schemaWatcher.onSchemaChange(callback);
+    }
+    /**
+     * Get performance metrics
+     */
+    getPerformanceMetrics() {
+        const baseMetrics = {
+            queryCount: this.logger.getQueryCount(),
+            averageQueryTime: this.logger.getAverageQueryTime(),
+            cacheHitRate: this.cacheManager.getHitRate(),
+            repositoryCount: this.repositories.size
+        };
+        if (this.queryAnalyzer) {
+            return {
+                ...baseMetrics,
+                ...this.queryAnalyzer.getPerformanceStats()
+            };
+        }
+        return baseMetrics;
+    }
+    /**
+     * Enable query performance monitoring
+     */
+    enablePerformanceMonitoring(options) {
+        if (!this.initialized) {
+            throw new NoormError_js_1.NoormError('NOORMME must be initialized before enabling performance monitoring');
+        }
+        const schemaInfo = this.cacheManager.get('schema');
+        if (!schemaInfo) {
+            throw new NoormError_js_1.NoormError('Schema not found. Please reinitialize NOORMME.');
+        }
+        this.queryAnalyzer = new query_analyzer_js_1.QueryAnalyzer(this.db, this.logger, schemaInfo, options);
+        this.logger.info('Query performance monitoring enabled');
+    }
+    /**
+     * Disable query performance monitoring
+     */
+    disablePerformanceMonitoring() {
+        if (this.queryAnalyzer) {
+            this.queryAnalyzer.clearHistory();
+            this.queryAnalyzer = null;
+            this.logger.info('Query performance monitoring disabled');
+        }
+    }
+    /**
+     * Close database connections
+     */
+    async close() {
+        this.logger.info('Closing NOORMME...');
+        // Stop schema watching if running
+        this.stopSchemaWatching();
+        await this.db.destroy();
+        await this.cacheManager.close();
+        this.initialized = false;
+        this.repositories.clear();
+        this.logger.info('NOORMME closed');
+    }
+    /**
+     * Get the underlying Kysely instance for custom queries
+     */
+    getKysely() {
+        return this.db;
+    }
+    /**
+     * Execute a transaction
+     */
+    async transaction(callback) {
+        return await this.db.transaction().execute(callback);
+    }
+    /**
+     * Execute raw SQL
+     */
+    async execute(sql, parameters) {
+        return await this.db.executeQuery({
+            sql,
+            parameters: parameters || []
+        });
+    }
+    mergeConfig(config) {
+        return {
+            dialect: config.dialect,
+            connection: config.connection,
+            introspection: {
+                includeViews: false,
+                excludeTables: [],
+                customTypeMappings: {},
+                ...config.introspection
+            },
+            cache: {
+                ttl: 300000, // 5 minutes
+                maxSize: 1000,
+                strategy: 'lru',
+                ...config.cache
+            },
+            logging: {
+                level: 'info',
+                enabled: true,
+                ...config.logging
+            },
+            performance: {
+                enableQueryOptimization: true,
+                enableBatchLoading: true,
+                maxBatchSize: 100,
+                ...config.performance
+            }
+        };
+    }
+    /**
+     * Parse connection string into NOORMConfig
+     */
+    parseConnectionString(connectionString) {
+        try {
+            const url = new URL(connectionString);
+            let dialect;
+            switch (url.protocol) {
+                case 'sqlite:':
+                    dialect = 'sqlite';
+                    break;
+                default:
+                    throw new NoormError_js_1.NoormError(`Unsupported database protocol: ${url.protocol}`, {
+                        operation: 'connection_string_parsing',
+                        suggestion: 'Supported protocols: sqlite'
+                    });
+            }
+            if (dialect === 'sqlite') {
+                return {
+                    dialect,
+                    connection: {
+                        database: url.pathname,
+                        host: '',
+                        port: 0,
+                        username: '',
+                        password: ''
+                    }
+                };
+            }
+            return {
+                dialect,
+                connection: {
+                    host: url.hostname || 'localhost',
+                    port: url.port ? parseInt(url.port) : this.getDefaultPort(dialect),
+                    database: url.pathname.slice(1), // Remove leading slash
+                    username: url.username || '',
+                    password: url.password || '',
+                    ssl: url.searchParams.get('ssl') === 'true' || url.searchParams.get('sslmode') === 'require'
+                }
+            };
+        }
+        catch (error) {
+            throw new NoormError_js_1.NoormError(`Failed to parse connection string: ${error instanceof Error ? error.message : String(error)}`, {
+                operation: 'connection_string_parsing',
+                suggestion: 'Ensure connection string format is: protocol://username:password@host:port/database'
+            });
+        }
+    }
+    /**
+     * Get default port for database dialect
+     */
+    getDefaultPort(dialect) {
+        switch (dialect) {
+            case 'sqlite': return 0;
+            default: return 0;
+        }
+    }
+    createDialect() {
+        const { dialect, connection } = this.config;
+        switch (dialect) {
+            case 'sqlite':
+                const Database = require('better-sqlite3');
+                return new (require('./dialect/sqlite/sqlite-dialect').SqliteDialect)({
+                    database: new Database(connection.database)
+                });
+            default:
+                throw new Error(`Unsupported dialect: ${dialect}`);
+        }
+    }
+}
+exports.NOORMME = NOORMME;
+// Export the main class as default
+exports.default = NOORMME;

package/dist/cjs/operation-node/add-column-node.d.ts

@@ -0,0 +1,13 @@
+import { ColumnDefinitionNode } from './column-definition-node.js';
+import { OperationNode } from './operation-node.js';
+export interface AddColumnNode extends OperationNode {
+    readonly kind: 'AddColumnNode';
+    readonly column: ColumnDefinitionNode;
+}
+/**
+ * @internal
+ */
+export declare const AddColumnNode: Readonly<{
+    is(node: OperationNode): node is AddColumnNode;
+    create(column: ColumnDefinitionNode): AddColumnNode;
+}>;

package/dist/cjs/operation-node/add-column-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddColumnNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.AddColumnNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AddColumnNode';
+    },
+    create(column) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AddColumnNode',
+            column,
+        });
+    },
+});

package/dist/cjs/operation-node/add-constraint-node.d.ts

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+import { ConstraintNode } from './constraint-node.js';
+export interface AddConstraintNode extends OperationNode {
+    readonly kind: 'AddConstraintNode';
+    readonly constraint: ConstraintNode;
+}
+/**
+ * @internal
+ */
+export declare const AddConstraintNode: Readonly<{
+    is(node: OperationNode): node is AddConstraintNode;
+    create(constraint: ConstraintNode): AddConstraintNode;
+}>;

package/dist/cjs/operation-node/add-constraint-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddConstraintNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.AddConstraintNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AddConstraintNode';
+    },
+    create(constraint) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AddConstraintNode',
+            constraint,
+        });
+    },
+});

package/dist/cjs/operation-node/add-index-node.d.ts

@@ -0,0 +1,21 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export type AddIndexNodeProps = Omit<AddIndexNode, 'kind' | 'name'>;
+export interface AddIndexNode extends OperationNode {
+    readonly kind: 'AddIndexNode';
+    readonly name: IdentifierNode;
+    readonly columns?: OperationNode[];
+    readonly unique?: boolean;
+    readonly using?: RawNode;
+    readonly ifNotExists?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const AddIndexNode: Readonly<{
+    is(node: OperationNode): node is AddIndexNode;
+    create(name: string): AddIndexNode;
+    cloneWith(node: AddIndexNode, props: AddIndexNodeProps): AddIndexNode;
+    cloneWithColumns(node: AddIndexNode, columns: OperationNode[]): AddIndexNode;
+}>;

package/dist/cjs/operation-node/add-index-node.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddIndexNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.AddIndexNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AddIndexNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AddIndexNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithColumns(node, columns) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            columns: [...(node.columns || []), ...columns],
+        });
+    },
+});

package/dist/cjs/operation-node/aggregate-function-node.d.ts

@@ -0,0 +1,27 @@
+import { OperationNode } from './operation-node.js';
+import { OverNode } from './over-node.js';
+import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
+export interface AggregateFunctionNode extends OperationNode {
+    readonly kind: 'AggregateFunctionNode';
+    readonly func: string;
+    readonly aggregated: readonly OperationNode[];
+    readonly distinct?: boolean;
+    readonly orderBy?: OrderByNode;
+    readonly withinGroup?: OrderByNode;
+    readonly filter?: WhereNode;
+    readonly over?: OverNode;
+}
+/**
+ * @internal
+ */
+export declare const AggregateFunctionNode: Readonly<{
+    is(node: OperationNode): node is AggregateFunctionNode;
+    create(aggregateFunction: string, aggregated?: readonly OperationNode[]): AggregateFunctionNode;
+    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>, withinGroup?: boolean): AggregateFunctionNode;
+    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
+    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
+    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;
+}>;