@ductape/sdk 0.0.4-v6 → 0.0.4-v60

package/dist/database/databases.service.d.ts

@@ -0,0 +1,1388 @@
+/**
+ * DatabaseService - Main ORM Service Class
+ *
+ * This is the primary entry point for all database operations in the Ductape SDK.
+ * It provides a unified interface for querying, writing, transactions, schema management,
+ * migrations, and database actions across multiple database types.
+ *
+ * Supported databases: PostgreSQL, MySQL, MongoDB, DynamoDB, MariaDB, Cassandra
+ */
+import { IConnectionConfig, IConnectionResult, IConnectionContext, IDatabaseConfig } from './types/connection.interface';
+import { IQueryOptions, IQueryResult, IRawQueryOptions, IRawQueryResult } from './types/query.interface';
+import { IInsertOptions, IInsertResult, IUpdateOptions, IUpdateResult, IDeleteOptions, IDeleteResult, IUpsertOptions, IUpsertResult } from './types/write.interface';
+import { ITransactionOptions, ITransaction, ITransactionCallback } from './types/transaction.interface';
+import { IAggregateOptions, IAggregateResult, ICountOptions, ISumOptions, IAvgOptions, IMinMaxOptions, IGroupByOptions, IGroupByResult } from './types/aggregation.interface';
+import { ICreateTableOptions, ITableDefinition, IAlterTableOperation, ITableSchema, ICreateIndexOptions, IDropIndexOptions, IListIndexesOptions, IIndexInfo, IIndexStatistics, SimpleFieldType, ISimpleFieldDefinition, ISimpleSchemaDefinition, ISimpleCreateOptions, ISimpleDropOptions, ISimpleIndexOptions } from './types/schema.interface';
+import { IIndexFieldDefinition, IConstraintDefinition as IMigrationConstraintDefinition, IMigration, IMigrationHistory, IMigrationStatusResult, IMigrationResult } from './types/migration.interface';
+import { ISchemaOperationResult } from './schema/schema-manager';
+import { IActionDefinition, IActionCreateOptions, IActionUpdateOptions, IActionExecuteOptions } from './types/action.interface';
+import { BaseAdapter } from './adapters/base.adapter';
+import { TriggerProcessor } from './triggers/trigger-processor';
+import { TriggerEvent, TriggerTiming, TriggerActionType, ITriggerDefinition, ITriggerContext, ITriggerResult } from './types/trigger.interface';
+import { IProductDatabase, IProductDatabaseTrigger } from '../types';
+import { RedisClientType } from 'redis';
+import { IDBActionDispatchInput, IDBOperationDispatchInput, IDispatchResult } from '../types/processor.types';
+/**
+ * Configuration options for DatabaseService initialization
+ */
+export interface IDatabaseServiceConfig {
+    /** Workspace ID */
+    workspace_id: string;
+    /** Public key for authentication */
+    public_key: string;
+    /** User ID */
+    user_id: string;
+    /** Authentication token */
+    token: string;
+    /** Environment type (staging, production, local) */
+    env_type: string;
+    private_key: string;
+    /** Optional Redis client for caching */
+    redis_client?: RedisClientType;
+}
+/**
+ * Main Database Service class
+ * Provides unified ORM interface for all supported databases
+ */
+export declare class DatabaseService {
+    private adapters;
+    private connectionContexts;
+    private currentContext;
+    private adapterFactory;
+    private transactionManager;
+    private schemaManagers;
+    private migrationEngines;
+    private actionManager;
+    private _privateKey;
+    /** Service configuration */
+    private config;
+    /** ProductBuilder instances cache (keyed by product tag) */
+    private productBuilders;
+    /** LogService instance for logging operations */
+    private logService;
+    /** Current product ID for logging */
+    private productId;
+    /** CacheManager for two-tier caching (Redis + remote) */
+    private cacheManager;
+    /** Private keys cache for products (keyed by product tag) */
+    private privateKeys;
+    /**
+     * Create a new DatabaseService instance
+     * @param config - Optional configuration for authentication and workspace context
+     */
+    constructor(config?: IDatabaseServiceConfig & {
+        access_key: string;
+    });
+    /**
+     * Get or create a SchemaManager for the given adapter key or current context
+     */
+    private getSchemaManager;
+    /**
+     * Get or create a MigrationEngine for the given adapter key or current context
+     */
+    private getMigrationEngine;
+    /**
+     * Create a new ProductBuilder instance
+     */
+    private createNewProductBuilder;
+    /**
+     * Get or create a ProductBuilder instance for the given product tag
+     */
+    private getProductBuilder;
+    /**
+     * Initialize logging service
+     */
+    private initializeLogService;
+    /**
+     * Create a new ProcessorService instance for job scheduling
+     */
+    private createNewProcessor;
+    /**
+     * Register a new database configuration for a product
+     * @param productTag - The product tag
+     * @param data - The database configuration data
+     */
+    registerDatabase(productTag: string, data: IProductDatabase): Promise<void>;
+    /**
+     * Fetch all databases for a product
+     * @param productTag - The product tag
+     * @returns Array of database configurations
+     */
+    fetchAllDatabases(productTag: string): Promise<IProductDatabase[]>;
+    /**
+     * Fetch a specific database by tag
+     * @param productTag - The product tag
+     * @param databaseTag - The database tag
+     * @returns The database configuration or null if not found
+     */
+    fetchDatabase(productTag: string, databaseTag: string): Promise<IProductDatabase | null>;
+    /**
+     * Update a database configuration
+     * @param productTag - The product tag
+     * @param databaseTag - The database tag
+     * @param data - The data to update
+     */
+    updateDatabase(productTag: string, databaseTag: string, data: Partial<IProductDatabase>): Promise<void>;
+    /**
+     * Create a database trigger
+     * @param productTag - The product tag
+     * @param data - The trigger configuration
+     */
+    createTrigger(productTag: string, data: Partial<IProductDatabaseTrigger>): Promise<void>;
+    /**
+     * Update a database trigger
+     * @param productTag - The product tag
+     * @param data - The trigger configuration
+     */
+    updateTrigger(productTag: string, data: Partial<IProductDatabaseTrigger>): Promise<void>;
+    /**
+     * Fetch a database trigger
+     * @param productTag - The product tag
+     * @param tag - The trigger tag (format: database_tag:trigger_tag)
+     */
+    fetchTrigger(productTag: string, tag: string): Promise<IProductDatabaseTrigger | null>;
+    /**
+     * Fetch all triggers for a database
+     * @param productTag - The product tag
+     * @param databaseTag - The database tag
+     */
+    fetchTriggers(productTag: string, databaseTag: string): Promise<IProductDatabaseTrigger[]>;
+    /**
+     * Delete a database trigger
+     * @param productTag - The product tag
+     * @param tag - The trigger tag (format: database_tag:trigger_tag)
+     */
+    deleteTrigger(productTag: string, tag: string): Promise<void>;
+    /**
+     * Get the current service configuration
+     */
+    getConfig(): IDatabaseServiceConfig | null;
+    /**
+     * Update the service configuration (used after auth is complete)
+     */
+    updateConfig(config: Partial<IDatabaseServiceConfig>): void;
+    /**
+     * Get workspace ID from config
+     */
+    getWorkspaceId(): string | null;
+    /**
+     * Get user ID from config
+     */
+    getUserId(): string | null;
+    /**
+     * Get authentication token from config
+     */
+    getToken(): string | null;
+    /**
+     * Get environment type from config
+     */
+    getEnvType(): string | null;
+    /**
+     * Create/register a new database configuration
+     *
+     * @example
+     * // Persist to product
+     * await ductape.database.create({
+     *   product: 'my-product',
+     *   name: 'User Database',
+     *   tag: 'users-db',
+     *   type: 'postgresql',
+     *   description: 'Stores user accounts and profiles',
+     *   envs: [
+     *     { slug: 'dev', connection_url: 'postgresql://localhost:5432/myapp_dev' },
+     *     { slug: 'prd', connection_url: 'postgresql://prod-host:5432/myapp_prod' },
+     *   ],
+     * });
+     *
+     * // Local only (not persisted)
+     * await ductape.database.create({
+     *   name: 'Temp Database',
+     *   tag: 'temp-db',
+     *   type: 'postgresql',
+     *   envs: [{ slug: 'dev', connection_url: 'postgresql://localhost:5432/temp' }],
+     * });
+     */
+    create(config: IDatabaseConfig): Promise<void>;
+    /**
+     * Generate a secret key for database connection URLs
+     * Format: DB_{PRODUCT}_{ASSET_TAG}_{ENV}_{KEY}
+     *
+     * Where:
+     * - PRODUCT = productTag.split('.')[1] (second part after workspace)
+     * - ASSET_TAG = if dbTag starts with same workspace prefix, use second part; otherwise sanitize full tag
+     * - All parts are automatically capitalized
+     */
+    private generateDbSecretKey;
+    /**
+     * Connect to a database
+     *
+     * @example
+     * const result = await ductape.database.connect({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'users-db',
+     * });
+     * console.log('Connected:', result.connected);
+     * console.log('Database Version:', result.version);
+     * console.log('Latency:', result.latency, 'ms');
+     *
+     * // With the returned connection object, you can use scoped operations:
+     * const db = await ductape.databases.connect({ env: 'dev', product: 'my-app', database: 'users-db' });
+     * await db.triggers.create({ tag: 'my-trigger', ... });
+     */
+    connect(config: IConnectionConfig): Promise<DatabaseConnection>;
+    /**
+     * Test database connection without establishing persistent connection
+     *
+     * @example
+     * const result = await ductape.database.testConnection({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'users-db',
+     * });
+     * if (result.connected) {
+     *   console.log('Connection successful!');
+     * } else {
+     *   console.error('Connection failed:', result.error);
+     * }
+     */
+    testConnection(config: IConnectionConfig): Promise<IConnectionResult>;
+    /**
+     * Disconnect from the current database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Close all database connections
+     *
+     * @example
+     * await ductape.database.closeAll();
+     */
+    closeAll(): Promise<void>;
+    /**
+     * Fetch all registered databases
+     *
+     * @example
+     * const databases = await ductape.database.fetchAll();
+     * databases.forEach((db) => {
+     *   console.log(`${db.name} (${db.tag}): ${db.type}`);
+     * });
+     */
+    fetchAll(product: string): Promise<IDatabaseConfig[]>;
+    /**
+     * Fetch a specific database configuration
+     *
+     * @example
+     * const usersDb = await ductape.database.fetch('users-db');
+     * console.log('Database:', usersDb.name);
+     * console.log('Type:', usersDb.type);
+     * console.log('Environments:', usersDb.envs);
+     */
+    fetch(product: string, database: string): Promise<IDatabaseConfig | null>;
+    /**
+     * Update a local database configuration
+     *
+     * @example
+     * await ductape.database.updateLocalConfig('users-db', {
+     *   name: 'User Database v2',
+     *   description: 'Updated user storage',
+     *   envs: [
+     *     { slug: 'dev', connection_url: 'postgresql://new-dev-host:5432/myapp' },
+     *   ],
+     * });
+     */
+    updateLocalConfig(tag: string, updates: Partial<IDatabaseConfig>): Promise<void>;
+    /**
+     * Query records from a table
+     *
+     * @example
+     * // With established connection
+     * const result = await ductape.database.query({
+     *   table: 'users',
+     *   where: { status: 'active' },
+     *   orderBy: { column: 'created_at', order: 'DESC' },
+     *   limit: 10,
+     * });
+     *
+     * // With explicit connection params
+     * const result = await ductape.database.query({
+     *   env: 'prd',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   table: 'users',
+     * });
+     */
+    query<T = any>(options: IQueryOptions): Promise<IQueryResult<T>>;
+    /**
+     * Execute a raw query
+     *
+     * @example
+     * // PostgreSQL
+     * const result = await ductape.database.raw({
+     *   query: 'SELECT * FROM users WHERE created_at > $1 AND status = $2',
+     *   params: [new Date('2024-01-01'), 'active'],
+     * });
+     *
+     * // MySQL
+     * const result = await ductape.database.raw({
+     *   query: 'SELECT * FROM users WHERE created_at > ? AND status = ?',
+     *   params: [new Date('2024-01-01'), 'active'],
+     * });
+     *
+     * // MongoDB
+     * const result = await ductape.database.raw({
+     *   query: { status: 'active', created_at: { $gte: new Date('2024-01-01') } },
+     *   collection: 'users',
+     * });
+     */
+    raw<T = any>(options: IRawQueryOptions): Promise<IRawQueryResult<T>>;
+    /**
+     * Insert one or more records
+     *
+     * @example
+     * // Single record
+     * const result = await ductape.database.insert({
+     *   table: 'users',
+     *   data: {
+     *     name: 'Jane Doe',
+     *     email: 'jane@example.com',
+     *     status: 'active',
+     *   },
+     *   returning: true,
+     * });
+     *
+     * // Multiple records
+     * const result = await ductape.database.insert({
+     *   table: 'users',
+     *   data: [
+     *     { name: 'User 1', email: 'user1@example.com' },
+     *     { name: 'User 2', email: 'user2@example.com' },
+     *   ],
+     * });
+     *
+     * // With conflict handling (upsert)
+     * const result = await ductape.database.insert({
+     *   table: 'users',
+     *   data: { email: 'john@example.com', name: 'John' },
+     *   onConflict: {
+     *     columns: ['email'],
+     *     action: 'update',
+     *     update: ['name'],
+     *   },
+     * });
+     */
+    insert<T = any>(options: IInsertOptions): Promise<IInsertResult<T>>;
+    /**
+     * Update records matching conditions
+     *
+     * @example
+     * // Simple update
+     * const result = await ductape.database.update({
+     *   table: 'users',
+     *   data: { status: 'inactive' },
+     *   where: { last_login: { $LT: new Date('2023-01-01') } },
+     * });
+     *
+     * // With increment/decrement
+     * await ductape.database.update({
+     *   table: 'products',
+     *   data: { stock: { $inc: 10 } },
+     *   where: { id: productId },
+     * });
+     */
+    update<T = any>(options: IUpdateOptions): Promise<IUpdateResult<T>>;
+    /**
+     * Delete records matching conditions
+     *
+     * @example
+     * const result = await ductape.database.delete({
+     *   table: 'users',
+     *   where: { status: 'deleted' },
+     * });
+     * console.log('Deleted count:', result.count);
+     */
+    delete(options: IDeleteOptions): Promise<IDeleteResult>;
+    /**
+     * Insert or update a record based on conflict keys
+     *
+     * @example
+     * const result = await ductape.database.upsert({
+     *   table: 'user_preferences',
+     *   data: {
+     *     user_id: 123,
+     *     theme: 'dark',
+     *     language: 'en',
+     *   },
+     *   conflictKeys: ['user_id'],
+     * });
+     * console.log('Operation:', result.operation); // 'inserted' or 'updated'
+     */
+    upsert<T = any>(options: IUpsertOptions): Promise<IUpsertResult<T>>;
+    /**
+     * Count records
+     *
+     * @example
+     * const count = await ductape.database.count({
+     *   table: 'users',
+     *   where: { status: 'active' },
+     * });
+     */
+    count(options: ICountOptions): Promise<number>;
+    /**
+     * Sum values of a column
+     *
+     * @example
+     * const totalRevenue = await ductape.database.sum({
+     *   table: 'orders',
+     *   column: 'total',
+     *   where: { status: 'completed' },
+     * });
+     */
+    sum(options: ISumOptions): Promise<number>;
+    /**
+     * Calculate average of a column
+     *
+     * @example
+     * const avgOrderValue = await ductape.database.avg({
+     *   table: 'orders',
+     *   column: 'total',
+     * });
+     */
+    avg(options: IAvgOptions): Promise<number>;
+    /**
+     * Get minimum value of a column
+     *
+     * @example
+     * const minPrice = await ductape.database.min({
+     *   table: 'products',
+     *   column: 'price',
+     * });
+     */
+    min(options: IMinMaxOptions): Promise<any>;
+    /**
+     * Get maximum value of a column
+     *
+     * @example
+     * const maxPrice = await ductape.database.max({
+     *   table: 'products',
+     *   column: 'price',
+     * });
+     */
+    max(options: IMinMaxOptions): Promise<any>;
+    /**
+     * Perform multiple aggregations in one query
+     *
+     * @example
+     * const stats = await ductape.database.aggregate({
+     *   table: 'orders',
+     *   operations: {
+     *     total_revenue: { $SUM: 'total' },
+     *     order_count: { $COUNT: '*' },
+     *     avg_order_value: { $AVG: 'total' },
+     *   },
+     *   where: { status: 'completed' },
+     * });
+     */
+    aggregate(options: IAggregateOptions): Promise<IAggregateResult>;
+    /**
+     * Group records and perform aggregations
+     *
+     * @example
+     * const salesByCategory = await ductape.database.groupBy({
+     *   table: 'products',
+     *   groupBy: ['category'],
+     *   operations: {
+     *     total_sales: { $SUM: 'sales_count' },
+     *     avg_price: { $AVG: 'price' },
+     *   },
+     *   having: {
+     *     total_sales: { $GT: 100 },
+     *   },
+     * });
+     */
+    groupBy<T = any>(options: IGroupByOptions): Promise<IGroupByResult<T>[]>;
+    /**
+     * Execute operations within a transaction (callback API - recommended)
+     *
+     * @example
+     * const order = await ductape.database.transaction({
+     *   env: 'prd',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     * }, async (transaction) => {
+     *   const order = await ductape.database.insert({
+     *     table: 'orders',
+     *     data: { customer_id: 123, total: 99.99 },
+     *     transaction,
+     *   });
+     *
+     *   await ductape.database.insert({
+     *     table: 'order_items',
+     *     data: items.map(item => ({ order_id: order.insertedIds[0], ...item })),
+     *     transaction,
+     *   });
+     *
+     *   return order;
+     * });
+     */
+    transaction<T>(options: ITransactionOptions, callback: ITransactionCallback<T>): Promise<T>;
+    /**
+     * Begin a transaction manually
+     *
+     * @example
+     * const transaction = await ductape.database.beginTransaction({
+     *   env: 'prd',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   isolationLevel: 'REPEATABLE_READ',
+     * });
+     *
+     * try {
+     *   await ductape.database.insert({ table: 'accounts', data: {...}, transaction });
+     *   await transaction.commit();
+     * } catch (error) {
+     *   await transaction.rollback();
+     *   throw error;
+     * }
+     */
+    beginTransaction(options: ITransactionOptions): Promise<ITransaction>;
+    /**
+     * Create a new table
+     *
+     * @example
+     * import { SchemaHelpers } from '@ductape/sdk';
+     *
+     * await ductape.database.createTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   {
+     *     name: 'products',
+     *     columns: [
+     *       SchemaHelpers.id(),
+     *       SchemaHelpers.string('name', 255, false),
+     *       SchemaHelpers.decimal('price', 10, 2),
+     *       ...SchemaHelpers.timestamps(),
+     *     ],
+     *   },
+     *   { ifNotExists: true }
+     * );
+     */
+    createTable(connectionConfigOrDefinition: IConnectionConfig | ITableDefinition, tableDefinitionOrOptions?: ITableDefinition | ICreateTableOptions, options?: ICreateTableOptions): Promise<void>;
+    /**
+     * Alter an existing table
+     *
+     * @example
+     * import { ColumnAlterationType, ColumnType } from '@ductape/sdk';
+     *
+     * // Add column
+     * await ductape.database.alterTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'products',
+     *   [{ type: ColumnAlterationType.ADD, column: { name: 'sku', type: ColumnType.STRING, length: 50 } }]
+     * );
+     *
+     * // Drop column
+     * await ductape.database.alterTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'products',
+     *   [{ type: ColumnAlterationType.DROP, columnName: 'old_field' }]
+     * );
+     *
+     * // Rename column
+     * await ductape.database.alterTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'products',
+     *   [{ type: ColumnAlterationType.RENAME, oldName: 'old_name', newName: 'new_name' }]
+     * );
+     */
+    alterTable(connectionConfigOrTableName: IConnectionConfig | string, tableNameOrAlterations: string | IAlterTableOperation[], alterations?: IAlterTableOperation[]): Promise<void>;
+    /**
+     * Drop a table
+     *
+     * @example
+     * await ductape.database.dropTable(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'old_table'
+     * );
+     */
+    dropTable(connectionConfigOrTableName: IConnectionConfig | string, tableName?: string): Promise<void>;
+    /**
+     * List all tables in the database
+     *
+     * @example
+     * const tables = await ductape.database.listTables({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     * });
+     */
+    listTables(connectionConfig?: IConnectionConfig): Promise<string[]>;
+    /**
+     * Check if a table exists
+     *
+     * @example
+     * const exists = await ductape.database.tableExists(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'users'
+     * );
+     */
+    tableExists(connectionConfigOrTableName: IConnectionConfig | string, tableName?: string): Promise<boolean>;
+    /**
+     * Get the schema of a table
+     *
+     * @example
+     * const schema = await ductape.database.getTableSchema(
+     *   { env: 'dev', product: 'my-app', database: 'main-db' },
+     *   'users'
+     * );
+     * console.log('Table:', schema.name);
+     * console.log('Columns:', schema.columns);
+     * console.log('Indexes:', schema.indexes);
+     */
+    getTableSchema(connectionConfigOrTableName: IConnectionConfig | string, tableName?: string): Promise<ITableSchema>;
+    /**
+     * Create an index
+     *
+     * @example
+     * await ductape.database.createIndex({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   table: 'users',
+     *   index: {
+     *     name: 'idx_users_email',
+     *     table: 'users',
+     *     columns: [{ name: 'email' }],
+     *     unique: true,
+     *   },
+     *   ifNotExists: true,
+     *   concurrent: true, // PostgreSQL: create without locking
+     * });
+     */
+    createIndex(options: ICreateIndexOptions): Promise<void>;
+    /**
+     * Drop an index
+     *
+     * @example
+     * await ductape.database.dropIndex({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   table: 'users',
+     *   indexName: 'idx_users_old',
+     *   ifExists: true,
+     *   concurrent: true,
+     * });
+     */
+    dropIndex(options: IDropIndexOptions): Promise<void>;
+    /**
+     * List all indexes on a table
+     *
+     * @example
+     * const indexes = await ductape.database.listIndexes({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   database: 'main-db',
+     *   table: 'users',
+     *   includeSystem: false,
+     * });
+     */
+    listIndexes(options: IListIndexesOptions): Promise<IIndexInfo[]>;
+    /**
+     * Get index statistics
+     *
+     * @example
+     * // All indexes on a table
+     * const stats = await ductape.database.getIndexStatistics(
+     *   { env: 'prd', product: 'my-app', database: 'main-db' },
+     *   'users'
+     * );
+     *
+     * // Specific index
+     * const emailStats = await ductape.database.getIndexStatistics(
+     *   { env: 'prd', product: 'my-app', database: 'main-db' },
+     *   'users',
+     *   'idx_users_email'
+     * );
+     */
+    getIndexStatistics(connectionConfig: IConnectionConfig, tableName: string, indexName?: string): Promise<IIndexStatistics[]>;
+    /**
+     * Run a migration
+     *
+     * @example
+     * const result = await ductape.database.runMigration([migration]);
+     * console.log('Migrated:', result.size);
+     */
+    runMigration(migrations: IMigration[], options?: {
+        dryRun?: boolean;
+        appliedBy?: string;
+    }): Promise<Map<string, IMigrationResult>>;
+    /**
+     * Rollback migrations
+     *
+     * @example
+     * const result = await ductape.database.rollbackMigration([migration], 1);
+     * console.log('Rolled back:', result.size);
+     */
+    rollbackMigration(migrations: IMigration[], count?: number): Promise<Map<string, IMigrationResult>>;
+    /**
+     * Get migration history (applied migrations)
+     *
+     * @example
+     * const history = await ductape.database.getMigrationHistory();
+     * history.forEach((entry) => {
+     *   console.log('Tag:', entry.tag);
+     *   console.log('Applied at:', entry.appliedAt);
+     * });
+     */
+    getMigrationHistory(): Promise<IMigrationHistory[]>;
+    /**
+     * Get status of all migrations
+     *
+     * @example
+     * const status = await ductape.database.getMigrationStatus(allMigrations);
+     * console.log('Pending:', status.pending);
+     */
+    getMigrationStatus(migrations: IMigration[]): Promise<IMigrationStatusResult>;
+    /**
+     * Migration management sub-object
+     * Provides CRUD operations for database migrations via ProductBuilder
+     */
+    get migration(): {
+        /**
+         * Create a new database migration
+         *
+         * @example
+         * await ductape.database.migration.create({
+         *   product: 'my-product',
+         *   database: 'main-db',
+         *   data: {
+         *     name: 'Add users table',
+         *     tag: 'main-db:add-users-table',
+         *     value: {
+         *       up: ['CREATE TABLE users (id SERIAL PRIMARY KEY, email VARCHAR(255))'],
+         *       down: ['DROP TABLE users'],
+         *     },
+         *   },
+         * });
+         */
+        create: (options: {
+            product: string;
+            database: string;
+            data: {
+                name: string;
+                tag: string;
+                description?: string;
+                value: {
+                    up: string[];
+                    down: string[];
+                };
+            };
+        }) => Promise<void>;
+        /**
+         * Update an existing database migration
+         *
+         * @example
+         * await ductape.database.migration.update({
+         *   product: 'my-product',
+         *   tag: 'main-db:add-users-table',
+         *   data: {
+         *     description: 'Updated description',
+         *   },
+         * });
+         */
+        update: (options: {
+            product: string;
+            tag: string;
+            data: {
+                name?: string;
+                description?: string;
+                value?: {
+                    up: string[];
+                    down: string[];
+                };
+            };
+        }) => Promise<void>;
+        /**
+         * Fetch a specific database migration
+         *
+         * @example
+         * const migration = await ductape.database.migration.fetch({
+         *   product: 'my-product',
+         *   tag: 'main-db:add-users-table',
+         * });
+         */
+        fetch: (options: {
+            product: string;
+            tag: string;
+        }) => Promise<any>;
+        /**
+         * Fetch all database migrations for a database
+         *
+         * @example
+         * const migrations = await ductape.database.migration.fetchAll({
+         *   product: 'my-product',
+         *   database: 'main-db',
+         * });
+         */
+        fetchAll: (options: {
+            product: string;
+            database: string;
+        }) => Promise<any[]>;
+        /**
+         * Delete a database migration
+         *
+         * @example
+         * await ductape.database.migration.delete({
+         *   product: 'my-product',
+         *   tag: 'main-db:add-users-table',
+         * });
+         */
+        delete: (options: {
+            product: string;
+            tag: string;
+        }) => Promise<void>;
+        /**
+         * Run a database migration (up)
+         * @deprecated Migration execution has been deprecated
+         */
+        run: (_options: {
+            product: string;
+            migration: string;
+            env: string;
+        }) => Promise<any>;
+        /**
+         * Rollback a database migration (down)
+         * @deprecated Migration execution has been deprecated
+         */
+        rollback: (_options: {
+            product: string;
+            migration: string;
+            env: string;
+        }) => Promise<any>;
+    };
+    /**
+     * Action management sub-object
+     */
+    get action(): {
+        /**
+         * Create a new database action
+         *
+         * @example
+         * await ductape.database.action.create({
+         *   name: 'Get Users Paginated',
+         *   tag: 'postgresdb:get-users-paginated',
+         *   tableName: 'users',
+         *   operation: DatabaseActionTypes.QUERY,
+         *   template: {
+         *     where: { is_active: true },
+         *     limit: '{{limit}}',
+         *     offset: '{{offset}}',
+         *   },
+         * });
+         */
+        create: (options: IActionCreateOptions) => Promise<void>;
+        /**
+         * Update an existing action
+         *
+         * @example
+         * await ductape.database.action.update({
+         *   tag: 'postgresdb:get-users',
+         *   template: { where: { status: '{{status}}' } },
+         * });
+         */
+        update: (options: IActionUpdateOptions) => Promise<void>;
+        /**
+         * Fetch a specific action
+         *
+         * @example
+         * const action = await ductape.database.action.fetch('postgresdb:get-users');
+         */
+        fetch: (tag: string) => Promise<IActionDefinition | null>;
+        /**
+         * Fetch all actions for a database
+         *
+         * @example
+         * const actions = await ductape.database.action.fetchAll('postgresdb');
+         */
+        fetchAll: (databaseTag: string) => Promise<IActionDefinition[]>;
+        /**
+         * Delete a database action
+         *
+         * @example
+         * await ductape.database.action.delete('postgresdb:get-users');
+         */
+        delete: (tag: string) => Promise<void>;
+        /**
+         * Dispatches a database action to run as a scheduled job.
+         * @param {IDBActionDispatchInput} data - The database action dispatch input.
+         * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+         * @example
+         * // Schedule a database action to run in 1 hour
+         * await ductape.databases.action.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   database: 'users-db',
+         *   event: 'cleanup-inactive',
+         *   input: { query: { inactive: true } },
+         *   schedule: { start_at: Date.now() + 3600000 }
+         * });
+         *
+         * // Run on a cron schedule
+         * await ductape.databases.action.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   database: 'analytics-db',
+         *   event: 'aggregate-daily',
+         *   input: { query: {} },
+         *   schedule: { cron: '0 0 * * *' } // Daily at midnight
+         * });
+         */
+        dispatch: (data: IDBActionDispatchInput) => Promise<IDispatchResult>;
+    };
+    /**
+     * Execute a database action
+     *
+     * @example
+     * const users = await ductape.database.execute({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   database: 'postgresdb',
+     *   action: 'get-users-paginated',
+     *   input: {
+     *     limit: 25,
+     *     offset: 0,
+     *   },
+     * });
+     */
+    execute<T = any>(options: IActionExecuteOptions): Promise<T>;
+    /**
+     * Dispatches a database operation to run as a scheduled job.
+     * Use this for direct database operations (query, insert, update, delete, etc.).
+     * @param {IDBOperationDispatchInput} data - The database operation dispatch input.
+     * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+     * @example
+     * // Schedule a database operation to run in 1 hour
+     * await ductape.databases.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   database: 'users-db',
+     *   operation: 'deleteMany',
+     *   input: { filter: { inactive: true, lastLogin: { $lt: '2024-01-01' } } },
+     *   schedule: { start_at: Date.now() + 3600000 }
+     * });
+     *
+     * // Run daily database cleanup
+     * await ductape.databases.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   database: 'logs-db',
+     *   operation: 'deleteMany',
+     *   input: { filter: { createdAt: { $lt: '$DateAdd($Now(), -30, "days")' } } },
+     *   schedule: { cron: '0 3 * * *' } // Daily at 3 AM
+     * });
+     */
+    dispatch(data: IDBOperationDispatchInput): Promise<IDispatchResult>;
+    /**
+     * Get the appropriate adapter for the operation
+     */
+    getAdapter(options?: {
+        env?: string;
+        database?: string;
+    }): BaseAdapter;
+    /**
+     * Get the current connection context
+     */
+    getCurrentContext(): IConnectionContext | null;
+    /**
+     * Get a connection-scoped interface for a specific database/environment.
+     * This ensures schema operations are isolated to a specific connection.
+     *
+     * @example
+     * const usersDb = db.connection('users-db', 'dev');
+     * await usersDb.schema.create('users', { ... });
+     *
+     * const ordersDb = db.connection('orders-db', 'dev');
+     * await ordersDb.schema.create('orders', { ... }); // Different connection
+     */
+    connection(database: string, env: string, product?: string): DatabaseConnection;
+    /**
+     * Build a context key from database and environment
+     */
+    private buildContextKey;
+    /**
+     * Convert DatabaseTypes (from product API) to DatabaseType (ORM internal)
+     */
+    private convertDatabaseType;
+    /**
+     * Simplified schema operations API (Mongoose-style)
+     *
+     * @example
+     * await db.connect({ env: 'dev', product: 'my-app', database: 'users-db' });
+     *
+     * // Create a table with Mongoose-style schema
+     * await db.schema.create('users', {
+     *   id: { type: 'uuid', primaryKey: true },
+     *   email: { type: 'string', length: 255, required: true, unique: true },
+     *   name: { type: 'string', length: 100 },
+     *   age: 'integer',  // Shorthand
+     *   status: { type: 'enum', enum: ['active', 'inactive'], default: 'active' },
+     * }, { timestamps: true });
+     */
+    get schema(): {
+        /**
+         * Create a collection/table with Mongoose-style schema definition
+         */
+        create: (name: string, definition: ISimpleSchemaDefinition, options?: ISimpleCreateOptions) => Promise<ISchemaOperationResult>;
+        /**
+         * Drop a collection/table
+         */
+        drop: (name: string, options?: ISimpleDropOptions) => Promise<ISchemaOperationResult>;
+        /**
+         * Add a field to a collection
+         */
+        addField: (collection: string, fieldName: string, definition: SimpleFieldType | ISimpleFieldDefinition) => Promise<ISchemaOperationResult>;
+        /**
+         * Drop a field from a collection
+         */
+        dropField: (collection: string, fieldName: string) => Promise<ISchemaOperationResult>;
+        /**
+         * Rename a field in a collection
+         */
+        renameField: (collection: string, oldName: string, newName: string) => Promise<ISchemaOperationResult>;
+        /**
+         * Modify a field's definition
+         */
+        modifyField: (collection: string, fieldName: string, changes: Partial<ISimpleFieldDefinition>) => Promise<ISchemaOperationResult>;
+        /**
+         * Create an index on a collection
+         */
+        createIndex: (collection: string, fields: string[] | IIndexFieldDefinition[], options?: ISimpleIndexOptions) => Promise<ISchemaOperationResult>;
+        /**
+         * Drop an index from a collection
+         */
+        dropIndex: (collection: string, indexName: string) => Promise<ISchemaOperationResult>;
+        /**
+         * Add a constraint (SQL databases only)
+         */
+        addConstraint: (collection: string, constraint: IMigrationConstraintDefinition) => Promise<ISchemaOperationResult>;
+        /**
+         * Drop a constraint (SQL databases only)
+         */
+        dropConstraint: (collection: string, constraintName: string) => Promise<ISchemaOperationResult>;
+        /**
+         * Rename a collection/table
+         */
+        rename: (oldName: string, newName: string) => Promise<ISchemaOperationResult>;
+        /**
+         * Check if a collection/table exists
+         */
+        exists: (name: string) => Promise<boolean>;
+        /**
+         * List all collections/tables
+         */
+        list: (schemaName?: string) => Promise<string[]>;
+        /**
+         * Get detailed schema information for a collection
+         */
+        describe: (name: string) => Promise<ITableSchema>;
+        /**
+         * List indexes on a collection
+         */
+        indexes: (collection: string) => Promise<IIndexInfo[]>;
+    };
+    /**
+     * Create a collection with Mongoose-style definition
+     */
+    private schemaCreate;
+    /**
+     * Drop a collection
+     */
+    private schemaDrop;
+    /**
+     * Add a field to a collection
+     */
+    private schemaAddField;
+    /**
+     * Drop a field from a collection
+     */
+    private schemaDropField;
+    /**
+     * Rename a field
+     */
+    private schemaRenameField;
+    /**
+     * Modify a field's definition
+     */
+    private schemaModifyField;
+    /**
+     * Create an index
+     */
+    private schemaCreateIndex;
+    /**
+     * Drop an index
+     */
+    private schemaDropIndex;
+    /**
+     * Add a constraint (SQL only)
+     */
+    private schemaAddConstraint;
+    /**
+     * Drop a constraint (SQL only)
+     */
+    private schemaDropConstraint;
+    /**
+     * Rename a collection
+     */
+    private schemaRename;
+    /**
+     * Check if collection exists
+     */
+    private schemaExists;
+    /**
+     * List all collections
+     */
+    private schemaList;
+    /**
+     * Describe a collection's schema
+     */
+    private schemaDescribe;
+    /**
+     * List indexes on a collection
+     */
+    private schemaListIndexes;
+    /**
+     * Convert Mongoose-style schema definition to IFieldDefinition array
+     */
+    private convertToFieldDefinitions;
+    /**
+     * Convert a single field definition
+     */
+    private convertFieldDefinition;
+    /**
+     * Normalize Mongoose-style type names to FieldType
+     */
+    private normalizeFieldType;
+    /**
+     * Normalize index fields to IIndexFieldDefinition array
+     */
+    private normalizeIndexFields;
+    /**
+     * Get adapter by context key (used by DatabaseConnection)
+     * @internal
+     */
+    getAdapterByContextKey(contextKey: string): BaseAdapter;
+}
+/**
+ * Connection-scoped database interface.
+ * Provides isolated schema, query, and aggregation operations for a specific database/environment.
+ */
+export declare class DatabaseConnection {
+    private service;
+    private _database;
+    private _env;
+    private _product;
+    private contextKey;
+    private triggerProcessor;
+    constructor(service: DatabaseService, database: string, env: string, product: string);
+    /** Database tag */
+    get database(): string;
+    /** Environment slug */
+    get env(): string;
+    /** Product tag */
+    get product(): string;
+    /** Get the adapter for this connection */
+    getAdapter(): BaseAdapter;
+    /**
+     * Schema operations scoped to this connection
+     */
+    get schema(): {
+        create: (name: string, definition: ISimpleSchemaDefinition, options?: ISimpleCreateOptions) => Promise<ISchemaOperationResult>;
+        drop: (name: string, options?: ISimpleDropOptions) => Promise<ISchemaOperationResult>;
+        addField: (collection: string, fieldName: string, definition: SimpleFieldType | ISimpleFieldDefinition) => Promise<ISchemaOperationResult>;
+        dropField: (collection: string, fieldName: string) => Promise<ISchemaOperationResult>;
+        renameField: (collection: string, oldName: string, newName: string) => Promise<ISchemaOperationResult>;
+        modifyField: (collection: string, fieldName: string, changes: Partial<ISimpleFieldDefinition>) => Promise<ISchemaOperationResult>;
+        createIndex: (collection: string, fields: string[] | IIndexFieldDefinition[], options?: ISimpleIndexOptions) => Promise<ISchemaOperationResult>;
+        dropIndex: (collection: string, indexName: string) => Promise<ISchemaOperationResult>;
+        addConstraint: (collection: string, constraint: IMigrationConstraintDefinition) => Promise<ISchemaOperationResult>;
+        dropConstraint: (collection: string, constraintName: string) => Promise<ISchemaOperationResult>;
+        rename: (oldName: string, newName: string) => Promise<ISchemaOperationResult>;
+        exists: (name: string) => Promise<boolean>;
+        list: (schemaName?: string) => Promise<string[]>;
+        describe: (name: string) => Promise<ITableSchema>;
+        indexes: (collection: string) => Promise<IIndexInfo[]>;
+    };
+    query<T = any>(options: Omit<IQueryOptions, 'database' | 'env'>): Promise<IQueryResult<T>>;
+    insert<T = any>(options: Omit<IInsertOptions, 'database' | 'env'>): Promise<IInsertResult<T>>;
+    update<T = any>(options: Omit<IUpdateOptions, 'database' | 'env'>): Promise<IUpdateResult<T>>;
+    delete(options: Omit<IDeleteOptions, 'database' | 'env'>): Promise<IDeleteResult>;
+    upsert<T = any>(options: Omit<IUpsertOptions, 'database' | 'env'>): Promise<IUpsertResult<T>>;
+    raw<T = any>(options: Omit<IRawQueryOptions, 'database' | 'env'>): Promise<IRawQueryResult<T>>;
+    count(options: Omit<ICountOptions, 'database' | 'env'>): Promise<number>;
+    sum(options: Omit<ISumOptions, 'database' | 'env'>): Promise<number>;
+    avg(options: Omit<IAvgOptions, 'database' | 'env'>): Promise<number>;
+    min(options: Omit<IMinMaxOptions, 'database' | 'env'>): Promise<any>;
+    max(options: Omit<IMinMaxOptions, 'database' | 'env'>): Promise<any>;
+    aggregate(options: Omit<IAggregateOptions, 'database' | 'env'>): Promise<IAggregateResult>;
+    groupBy<T = any>(options: Omit<IGroupByOptions, 'database' | 'env'>): Promise<IGroupByResult<T>[]>;
+    /**
+     * Trigger operations scoped to this connection
+     */
+    get triggers(): {
+        /**
+         * Create a trigger and store it on the backend
+         * @param data - Trigger configuration (tag should be just the trigger name, database tag is added automatically)
+         */
+        create: (data: Partial<IProductDatabaseTrigger>) => Promise<void>;
+        /**
+         * Update an existing trigger on the backend
+         * @param data - Trigger configuration
+         */
+        update: (data: Partial<IProductDatabaseTrigger>) => Promise<void>;
+        /**
+         * Fetch a specific trigger from the backend
+         * @param triggerTag - The trigger tag (without database prefix)
+         */
+        fetch: (triggerTag: string) => Promise<IProductDatabaseTrigger | null>;
+        /**
+         * Fetch all triggers for this database from the backend
+         * @deprecated Use list() instead
+         */
+        fetchAll: () => Promise<IProductDatabaseTrigger[]>;
+        /**
+         * List all triggers for this database from the backend
+         * @param options - Optional filters (table, event, enabled)
+         */
+        list: (options?: {
+            table?: string;
+            event?: string;
+            enabled?: boolean;
+        }) => Promise<IProductDatabaseTrigger[]>;
+        /**
+         * Delete a trigger from the backend
+         * @param triggerTag - The trigger tag (without database prefix)
+         */
+        delete: (triggerTag: string) => Promise<boolean>;
+        /**
+         * Register a trigger in memory for the current session (does not persist to backend)
+         * @deprecated Use create() for persistent triggers
+         */
+        register: (table: string, trigger: ITriggerDefinition) => void;
+        /**
+         * Register multiple triggers in memory (does not persist to backend)
+         * @deprecated Use create() for persistent triggers
+         */
+        registerAll: (triggers: Array<{
+            table: string;
+            trigger: ITriggerDefinition;
+        }>) => void;
+        /**
+         * Unregister a trigger from memory
+         */
+        unregister: (table: string, triggerName: string) => boolean;
+        /**
+         * Get all triggers for a table and event
+         */
+        getTriggersForEvent: (table: string, event: TriggerEvent) => ITriggerDefinition[];
+        /**
+         * Execute all triggers for an event
+         */
+        execute: (event: TriggerEvent, context: Omit<ITriggerContext, "database" | "env">) => Promise<ITriggerResult[]>;
+        /**
+         * Load triggers from the backend and register them in memory
+         */
+        load: () => Promise<void>;
+        /**
+         * Set the Ductape instance for trigger actions
+         */
+        setDuctapeInstance: (instance: any) => void;
+        /**
+         * Get the trigger processor instance
+         */
+        getProcessor: () => TriggerProcessor;
+        /**
+         * Trigger action builders
+         */
+        Trigger: {
+            database: {
+                insert: (table: string, data: Record<string, any> | string) => import("./types/trigger.interface").ITriggerDatabaseAction;
+                update: (table: string, data: Record<string, any> | string, where: Record<string, any> | string) => import("./types/trigger.interface").ITriggerDatabaseAction;
+                delete: (table: string, where: Record<string, any> | string) => import("./types/trigger.interface").ITriggerDatabaseAction;
+                query: (table: string, where: Record<string, any> | string) => import("./types/trigger.interface").ITriggerDatabaseAction;
+            };
+            storage: {
+                upload: (storage: string, path: string, options?: Partial<import("./types/trigger.interface").ITriggerStorageAction>) => import("./types/trigger.interface").ITriggerStorageAction;
+                delete: (storage: string, path: string) => import("./types/trigger.interface").ITriggerStorageAction;
+                copy: (storage: string, sourcePath: string, destinationPath: string) => import("./types/trigger.interface").ITriggerStorageAction;
+            };
+            notification: {
+                email: (notification: string, recipients: string | string[], options?: Partial<import("./types/trigger.interface").ITriggerNotificationAction>) => import("./types/trigger.interface").ITriggerNotificationAction;
+                sms: (notification: string, recipients: string | string[], options?: Partial<import("./types/trigger.interface").ITriggerNotificationAction>) => import("./types/trigger.interface").ITriggerNotificationAction;
+                push: (notification: string, recipients: string | string[], options?: Partial<import("./types/trigger.interface").ITriggerNotificationAction>) => import("./types/trigger.interface").ITriggerNotificationAction;
+                callback: (notification: string, options?: Partial<import("./types/trigger.interface").ITriggerNotificationAction>) => import("./types/trigger.interface").ITriggerNotificationAction;
+            };
+            broker: {
+                publish: (event: string, message: Record<string, any> | string, options?: Partial<import("./types/trigger.interface").ITriggerBrokerAction>) => import("./types/trigger.interface").ITriggerBrokerAction;
+            };
+            cache: {
+                set: (cache: string, key: string, value: any, ttl?: number) => import("./types/trigger.interface").ITriggerCacheAction;
+                invalidate: (cache: string, pattern: string) => import("./types/trigger.interface").ITriggerCacheAction;
+                delete: (cache: string, key: string) => import("./types/trigger.interface").ITriggerCacheAction;
+            };
+            workflow: {
+                execute: (workflow: string, input?: Record<string, any> | string) => import("./types/trigger.interface").ITriggerWorkflowAction;
+                dispatch: (workflow: string, input?: Record<string, any> | string) => import("./types/trigger.interface").ITriggerWorkflowAction;
+            };
+            action: {
+                execute: (app: string, action: string, input?: Record<string, any> | string) => import("./types/trigger.interface").ITriggerActionExecuteAction;
+            };
+            agent: {
+                run: (agent: string, prompt?: string, input?: Record<string, any> | string) => import("./types/trigger.interface").ITriggerAgentAction;
+            };
+            log: {
+                debug: (message: string, data?: Record<string, any> | string) => import("./types/trigger.interface").ITriggerLogAction;
+                info: (message: string, data?: Record<string, any> | string) => import("./types/trigger.interface").ITriggerLogAction;
+                warn: (message: string, data?: Record<string, any> | string) => import("./types/trigger.interface").ITriggerLogAction;
+                error: (message: string, data?: Record<string, any> | string) => import("./types/trigger.interface").ITriggerLogAction;
+            };
+            http: {
+                get: (url: string, options?: Partial<import("./types/trigger.interface").ITriggerHttpAction>) => import("./types/trigger.interface").ITriggerHttpAction;
+                post: (url: string, body?: Record<string, any> | string, options?: Partial<import("./types/trigger.interface").ITriggerHttpAction>) => import("./types/trigger.interface").ITriggerHttpAction;
+                put: (url: string, body?: Record<string, any> | string, options?: Partial<import("./types/trigger.interface").ITriggerHttpAction>) => import("./types/trigger.interface").ITriggerHttpAction;
+                patch: (url: string, body?: Record<string, any> | string, options?: Partial<import("./types/trigger.interface").ITriggerHttpAction>) => import("./types/trigger.interface").ITriggerHttpAction;
+                delete: (url: string, options?: Partial<import("./types/trigger.interface").ITriggerHttpAction>) => import("./types/trigger.interface").ITriggerHttpAction;
+            };
+            custom: (handler: (context: ITriggerContext) => Promise<any>) => import("./types/trigger.interface").ITriggerCustomAction;
+            when: {
+                field: (field: string) => {
+                    equals: (value: any) => import("./types/trigger.interface").IConditionClause;
+                    notEquals: (value: any) => import("./types/trigger.interface").IConditionClause;
+                    greaterThan: (value: any) => import("./types/trigger.interface").IConditionClause;
+                    lessThan: (value: any) => import("./types/trigger.interface").IConditionClause;
+                    in: (values: any[]) => import("./types/trigger.interface").IConditionClause;
+                    contains: (value: string) => import("./types/trigger.interface").IConditionClause;
+                    isNull: () => import("./types/trigger.interface").IConditionClause;
+                    isNotNull: () => import("./types/trigger.interface").IConditionClause;
+                    changed: () => import("./types/trigger.interface").IConditionClause;
+                    changedTo: (value: any) => import("./types/trigger.interface").IConditionClause;
+                    changedFrom: (value: any) => import("./types/trigger.interface").IConditionClause;
+                };
+                and: (...conditions: (import("./types/trigger.interface").IConditionClause | import("./types/trigger.interface").ITriggerCondition)[]) => import("./types/trigger.interface").ITriggerCondition;
+                or: (...conditions: (import("./types/trigger.interface").IConditionClause | import("./types/trigger.interface").ITriggerCondition)[]) => import("./types/trigger.interface").ITriggerCondition;
+                not: (condition: import("./types/trigger.interface").IConditionClause | import("./types/trigger.interface").ITriggerCondition) => import("./types/trigger.interface").ITriggerCondition;
+            };
+        };
+        /**
+         * Trigger events enum
+         */
+        TriggerEvent: typeof TriggerEvent;
+        /**
+         * Trigger timing enum
+         */
+        TriggerTiming: typeof TriggerTiming;
+        /**
+         * Trigger action types enum
+         */
+        TriggerActionType: typeof TriggerActionType;
+    };
+}
+export declare const databaseService: DatabaseService;