ts-prorm-orm 1.1.0 → 1.2.0

package/dist/query-interface.d.ts

@@ -0,0 +1,407 @@
+/**
+ * QueryInterface - Provides methods for executing database operations during migrations
+ * Works with all supported dialects: SQLite, MySQL, PostgreSQL, MariaDB
+ */
+import { Dialect, TableOptions, DropTableOptions, TableDescription, IndexOptions, ViewOptions, DropViewOptions, MaterializedViewOptions, DropMaterializedViewOptions, RefreshOptions } from './dialects/dialect';
+import { type SequenceOptions, type PolicyOptions, type FullTextIndexOptions, type TriggerDefinition } from './schema-objects';
+import { Transaction, DataType, WhereOptions, PartitionType, PartitionBound, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions } from './types';
+/**
+ * QueryInterface options for various operations
+ */
+export interface QueryInterfaceOptions {
+    transaction?: Transaction;
+    logging?: boolean | ((sql: string, time?: number) => void);
+    benchmark?: boolean;
+}
+/**
+ * Column definition for createTable/alterTable
+ */
+export interface TableColumnDefinition {
+    type: DataType | string;
+    allowNull?: boolean;
+    defaultValue?: any;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    unique?: boolean | string;
+    references?: {
+        model: string;
+        key: string;
+        deferrable?: string;
+        onDelete?: string;
+        onUpdate?: string;
+    };
+    comment?: string;
+    validate?: Record<string, any>;
+}
+/**
+ * Index definition for addIndex
+ */
+export interface IndexFieldDefinition {
+    name: string;
+    length?: number | string;
+    order?: 'ASC' | 'DESC';
+    collate?: string;
+    /** Expression for expression-based indexes (e.g., "LOWER(column_name)") */
+    expression?: string;
+}
+/**
+ * Constraint definition for addConstraint
+ */
+export interface ConstraintDefinition {
+    type: 'UNIQUE' | 'PRIMARY KEY' | 'FOREIGN KEY' | 'CHECK';
+    fields?: string[];
+    name?: string;
+    references?: {
+        table: string;
+        fields: string[];
+    };
+    onDelete?: string;
+    onUpdate?: string;
+    where?: WhereOptions;
+}
+/**
+ * Bulk operation options
+ */
+export interface BulkOperationOptions {
+    transaction?: Transaction;
+    logging?: boolean | ((sql: string, time?: number) => void);
+    benchmark?: boolean;
+    validate?: boolean;
+    fields?: string[];
+    returning?: boolean | string[];
+}
+/**
+ * CreateQueryInterface - Provides migration operations for all database dialects
+ */
+export declare class CreateQueryInterface {
+    private dialect;
+    /**
+     * Create a new QueryInterface instance
+     * @param dialect - The database dialect to use
+     */
+    constructor(dialect: Dialect);
+    /**
+     * Get the dialect instance
+     */
+    getDialect(): Dialect;
+    /**
+     * Create a new table
+     * @param tableName - Name of the table to create
+     * @param columns - Column definitions
+     * @param options - Table options
+     */
+    createTable(tableName: string, columns: Record<string, TableColumnDefinition>, options?: TableOptions & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Create a partitioned table (PostgreSQL 10+)
+     * @param tableName - Name of the table to create
+     * @param columns - Column definitions
+     * @param options - Table options including partition configuration
+     */
+    createPartitionedTable(tableName: string, columns: Record<string, TableColumnDefinition>, options?: TableOptions & QueryInterfaceOptions & {
+        partitionBy: {
+            type: PartitionType;
+            column: string | string[];
+        };
+        partitions?: {
+            name: string;
+            bound?: PartitionBound;
+            tablespace?: string;
+            storageParameters?: Record<string, string | number>;
+        }[];
+    }): Promise<void>;
+    /**
+     * Create a partition for an existing partitioned table (PostgreSQL 10+)
+     * @param options - Partition creation options
+     */
+    createPartition(options: CreatePartitionOptions): Promise<void>;
+    /**
+     * Attach a partition to a partitioned table (PostgreSQL 11+)
+     * @param options - Partition attachment options
+     */
+    attachPartition(options: AttachPartitionOptions): Promise<void>;
+    /**
+     * Detach a partition from a partitioned table (PostgreSQL 11+)
+     * @param options - Partition detachment options
+     */
+    detachPartition(options: DetachPartitionOptions): Promise<void>;
+    /**
+     * Drop a partition (PostgreSQL 10+)
+     * @param partitionName - Name of the partition to drop
+     * @param options - Drop options
+     */
+    dropPartition(partitionName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    } & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Drop a table
+     * @param tableName - Name of the table to drop
+     * @param options - Drop options
+     */
+    dropTable(tableName: string, options?: DropTableOptions & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Drop all tables (dialect-specific)
+     */
+    dropAllTables(_options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Rename a table
+     * @param oldName - Current table name
+     * @param newName - New table name
+     */
+    renameTable(oldName: string, newName: string, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Add a column to a table
+     * @param tableName - Name of the table
+     * @param columnName - Name of the new column
+     * @param definition - Column definition
+     */
+    addColumn(tableName: string, columnName: string, definition: TableColumnDefinition, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Remove a column from a table
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column to remove
+     */
+    removeColumn(tableName: string, columnName: string, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Change a column definition
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column to change
+     * @param definition - New column definition
+     */
+    changeColumn(tableName: string, columnName: string, definition: TableColumnDefinition, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Rename a column
+     * @param tableName - Name of the table
+     * @param oldColumnName - Current column name
+     * @param newColumnName - New column name
+     */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Add an index to a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     * @param fields - Fields to include in the index
+     * @param options - Index options
+     */
+    addIndex(tableName: string, indexNameOrFields: string | string[] | IndexFieldDefinition[], fieldsOrOptions?: string[] | IndexFieldDefinition[] | (IndexOptions & QueryInterfaceOptions), options?: IndexOptions & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Remove an index from a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index to remove
+     */
+    removeIndex(tableName: string, indexName: string, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Show all indexes for a table
+     * @param tableName - Name of the table
+     */
+    showIndexes(tableName: string): Promise<{
+        name: string;
+        fields: string[];
+        unique: boolean;
+    }[]>;
+    /**
+     * Add a constraint to a table
+     * @param tableName - Name of the table
+     * @param constraintName - Name of the constraint
+     * @param constraint - Constraint definition
+     */
+    addConstraint(tableName: string, constraintNameOrOptions: string | (ConstraintDefinition & {
+        name?: string;
+    }), constraintOrOptions?: ConstraintDefinition, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Remove a constraint from a table
+     * @param tableName - Name of the table
+     * @param constraintName - Name of the constraint to remove
+     */
+    removeConstraint(tableName: string, constraintName: string, _typeOrOptions?: string | QueryInterfaceOptions): Promise<void>;
+    /**
+     * Check if an index exists on a table
+     */
+    indexExists(tableName: string, indexName: string): Promise<boolean>;
+    /**
+     * Bulk insert records
+     * @param tableName - Name of the table
+     * @param records - Records to insert
+     * @param options - Insert options
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], _options?: BulkOperationOptions): Promise<number>;
+    /**
+     * Bulk update records
+     * @param tableName - Name of the table
+     * @param values - Values to update
+     * @param where - Where clause
+     * @param options - Update options
+     */
+    bulkUpdate(tableName: string, values: Record<string, any>, where: WhereOptions, _options?: BulkOperationOptions): Promise<number>;
+    /**
+     * Bulk delete records
+     * @param tableName - Name of the table
+     * @param where - Where clause
+     * @param options - Delete options
+     */
+    bulkDelete(tableName: string, where: WhereOptions, _options?: BulkOperationOptions): Promise<number>;
+    /**
+     * Describe a table (get column information)
+     * @param tableName - Name of the table
+     */
+    describeTable(tableName: string): Promise<TableDescription>;
+    /**
+     * Show all tables in the database
+     */
+    showTables(): Promise<string[]>;
+    /**
+     * Check if a table exists
+     * @param tableName - Name of the table
+     */
+    tableExists(tableName: string): Promise<boolean>;
+    /**
+     * Get all table names with schema (for PostgreSQL, MySQL, etc.)
+     * @param _schema - Optional schema name
+     */
+    getTableNames(_schema?: string): Promise<string[]>;
+    /**
+     * Get foreign keys for a table
+     * @param tableName - Name of the table
+     */
+    getForeignKeysForTable(_tableName: string): Promise<any[]>;
+    /**
+     * Get constraints for a table
+     * @param tableName - Name of the table
+     */
+    getConstraints(_tableName: string): Promise<any[]>;
+    /**
+     * Create a database (for databases that support it)
+     * @param databaseName - Name of the database
+     */
+    createDatabase(_databaseName: string, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Drop a database (for databases that support it)
+     * @param databaseName - Name of the database
+     */
+    dropDatabase(_databaseName: string, _options?: QueryInterfaceOptions): Promise<void>;
+    /**
+     * Create a database view
+     * @param viewName - Name of the view to create
+     * @param query - The SELECT query for the view
+     * @param options - View options
+     */
+    createView(viewName: string, query: string, options?: ViewOptions & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Drop a database view
+     * @param viewName - Name of the view to drop
+     * @param options - Drop options
+     */
+    dropView(viewName: string, options?: DropViewOptions & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Show all views in the database
+     */
+    showViews(): Promise<string[]>;
+    /**
+     * Check if a view exists
+     * @param viewName - Name of the view
+     */
+    viewExists(viewName: string): Promise<boolean>;
+    /**
+     * Create a materialized view
+     * @param options - Materialized view options
+     */
+    createMaterializedView(options: MaterializedViewOptions & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Refresh a materialized view
+     * @param viewName - Name of the materialized view to refresh
+     * @param options - Refresh options
+     */
+    refreshMaterializedView(viewName: string, options?: RefreshOptions & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Drop a materialized view
+     * @param viewName - Name of the materialized view to drop
+     * @param options - Drop options
+     */
+    dropMaterializedView(viewName: string, options?: DropMaterializedViewOptions & QueryInterfaceOptions): Promise<void>;
+    /**
+     * Check if a materialized view exists
+     * @param viewName - Name of the materialized view
+     */
+    materializedViewExists(viewName: string): Promise<boolean>;
+    /**
+     * Show all materialized views in the database
+     */
+    showMaterializedViews(): Promise<string[]>;
+    private get _quoteId();
+    private get _quoteTable();
+    private get _dialectName();
+    /**
+     * Create a sequence.
+     *
+     * @example
+     * ```typescript
+     * await qi.createSequence('order_id_seq', { start: 1000, increment: 1 });
+     * ```
+     */
+    createSequence(name: string, options?: SequenceOptions): Promise<void>;
+    /** Drop a sequence. */
+    dropSequence(name: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a trigger.
+     *
+     * On PostgreSQL this also creates the backing trigger function, which the
+     * database requires and which a hand-written `CREATE TRIGGER` easily forgets.
+     */
+    createTrigger(trigger: TriggerDefinition): Promise<void>;
+    /** Drop a trigger. */
+    dropTrigger(name: string, table: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /** Enable row-level security on a table (PostgreSQL family). */
+    enableRowLevelSecurity(table: string): Promise<void>;
+    /** Disable row-level security on a table (PostgreSQL family). */
+    disableRowLevelSecurity(table: string): Promise<void>;
+    /**
+     * Create a row-level security policy.
+     *
+     * @example
+     * ```typescript
+     * await qi.createPolicy({
+     *   name: 'users_own_rows',
+     *   table: 'users',
+     *   for: 'SELECT',
+     *   using: 'user_id = current_user_id()',
+     * });
+     * ```
+     */
+    createPolicy(options: PolicyOptions): Promise<void>;
+    /** Drop a row-level security policy. */
+    dropPolicy(name: string, table: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a full-text index.
+     *
+     * Emits a GIN index over `to_tsvector` on PostgreSQL, a FULLTEXT index on
+     * MySQL/MariaDB, and an FTS5 virtual table on SQLite.
+     */
+    createFullTextIndex(options: FullTextIndexOptions): Promise<void>;
+    /**
+     * Execute a raw query
+     * @param sql - The SQL query
+     * @param options - Query options
+     */
+    query(sql: string, options?: QueryInterfaceOptions): Promise<any>;
+    /**
+     * Quote an identifier
+     * @param identifier - The identifier to quote
+     */
+    quoteIdentifier(identifier: string): string;
+    /**
+     * Escape a value
+     * @param value - The value to escape
+     */
+    escape(value: any): string;
+}
+/**
+ * Factory function to create a QueryInterface from a Prorm instance
+ */
+export declare function createQueryInterface(dialect: Dialect): CreateQueryInterface;
+export type QueryInterface = CreateQueryInterface;

package/dist/query-interface.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateQueryInterface = void 0;
 exports.createQueryInterface = createQueryInterface;
+const schema_objects_1 = require("./schema-objects");
 /**
  * CreateQueryInterface - Provides migration operations for all database dialects
  */
@@ -590,6 +591,89 @@ class CreateQueryInterface {
     async showMaterializedViews() {
         return this.dialect.showMaterializedViews();
     }
+    // ==================== Sequences, triggers, RLS, full-text ====================
+    //
+    // These object types previously had no API at all, so the only way to create
+    // them was a hand-written `prorm.query()` call - which is what the README's
+    // own per-dialect examples did. Each method builds dialect-appropriate SQL and
+    // raises UnsupportedSchemaObjectError where the database has no equivalent.
+    get _quoteId() {
+        return (id) => this.dialect.quoteIdentifier(id);
+    }
+    get _quoteTable() {
+        return (t) => this.dialect.quoteTable(t);
+    }
+    get _dialectName() {
+        return this.dialect.name;
+    }
+    /**
+     * Create a sequence.
+     *
+     * @example
+     * ```typescript
+     * await qi.createSequence('order_id_seq', { start: 1000, increment: 1 });
+     * ```
+     */
+    async createSequence(name, options = {}) {
+        await this.dialect.query((0, schema_objects_1.buildCreateSequenceSQL)(name, options, this._dialectName, this._quoteId));
+    }
+    /** Drop a sequence. */
+    async dropSequence(name, options) {
+        await this.dialect.query((0, schema_objects_1.buildDropSequenceSQL)(name, this._dialectName, this._quoteId, options?.ifExists ?? true));
+    }
+    /**
+     * Create a trigger.
+     *
+     * On PostgreSQL this also creates the backing trigger function, which the
+     * database requires and which a hand-written `CREATE TRIGGER` easily forgets.
+     */
+    async createTrigger(trigger) {
+        const statements = (0, schema_objects_1.buildCreateTriggerStatements)(trigger, this._dialectName, this._quoteId, this._quoteTable);
+        for (const sql of statements) {
+            await this.dialect.query(sql);
+        }
+    }
+    /** Drop a trigger. */
+    async dropTrigger(name, table, options) {
+        await this.dialect.query((0, schema_objects_1.buildDropTriggerSQL)(name, table, this._dialectName, this._quoteId, this._quoteTable, options?.ifExists ?? true));
+    }
+    /** Enable row-level security on a table (PostgreSQL family). */
+    async enableRowLevelSecurity(table) {
+        await this.dialect.query((0, schema_objects_1.buildEnableRowLevelSecuritySQL)(table, this._dialectName, this._quoteTable, true));
+    }
+    /** Disable row-level security on a table (PostgreSQL family). */
+    async disableRowLevelSecurity(table) {
+        await this.dialect.query((0, schema_objects_1.buildEnableRowLevelSecuritySQL)(table, this._dialectName, this._quoteTable, false));
+    }
+    /**
+     * Create a row-level security policy.
+     *
+     * @example
+     * ```typescript
+     * await qi.createPolicy({
+     *   name: 'users_own_rows',
+     *   table: 'users',
+     *   for: 'SELECT',
+     *   using: 'user_id = current_user_id()',
+     * });
+     * ```
+     */
+    async createPolicy(options) {
+        await this.dialect.query((0, schema_objects_1.buildCreatePolicySQL)(options, this._dialectName, this._quoteId, this._quoteTable));
+    }
+    /** Drop a row-level security policy. */
+    async dropPolicy(name, table, options) {
+        await this.dialect.query((0, schema_objects_1.buildDropPolicySQL)(name, table, this._dialectName, this._quoteId, this._quoteTable, options?.ifExists ?? true));
+    }
+    /**
+     * Create a full-text index.
+     *
+     * Emits a GIN index over `to_tsvector` on PostgreSQL, a FULLTEXT index on
+     * MySQL/MariaDB, and an FTS5 virtual table on SQLite.
+     */
+    async createFullTextIndex(options) {
+        await this.dialect.query((0, schema_objects_1.buildCreateFullTextIndexSQL)(options, this._dialectName, this._quoteId, this._quoteTable));
+    }
     /**
      * Execute a raw query
      * @param sql - The SQL query

package/dist/query-optimizers/batch-optimizer.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Query Batch/Bulk Optimization
+ * Provides functionality to optimize batch operations for better performance
+ */
+import { Dialect } from '../dialects/dialect';
+/**
+ * Options for batch operations
+ */
+export interface BatchOptions {
+    /** Maximum number of records per batch/chunk */
+    chunkSize: number;
+    /** Whether to use transactions for batch operations */
+    useTransaction?: boolean;
+    /** Whether to validate records before insertion */
+    validate?: boolean;
+    /** Whether to skip duplicate key errors */
+    skipDuplicates?: boolean;
+    /** Logging function */
+    logging?: (message: string) => void;
+    /** Callback for progress updates */
+    onProgress?: (progress: BatchProgress) => void;
+    /** Throw on error or continue with other batches */
+    stopOnError?: boolean;
+}
+/**
+ * Batch progress information
+ */
+export interface BatchProgress {
+    /** Total number of records */
+    total: number;
+    /** Number of processed records */
+    processed: number;
+    /** Number of successful operations */
+    success: number;
+    /** Number of failed operations */
+    failed: number;
+    /** Current batch index */
+    batchIndex: number;
+    /** Total number of batches */
+    totalBatches: number;
+}
+/**
+ * Result of a batch operation
+ */
+export interface BatchResult<T = any> {
+    /** Array of successfully processed records */
+    success: T[];
+    /** Array of failed records with error info */
+    failed: Array<{
+        record: T;
+        error: Error;
+    }>;
+    /** Total number of records processed */
+    total: number;
+    /** Number of records per batch */
+    chunkSize: number;
+    /** Total number of batches */
+    batches: number;
+    /** Total duration in milliseconds */
+    duration: number;
+}
+/**
+ * Single query in a batch
+ */
+export interface QueryBatch {
+    sql: string;
+    params?: any[];
+    values?: Record<string, any>;
+}
+/**
+ * Batch query optimizer
+ */
+export declare class BatchQueryOptimizer {
+    private dialect;
+    private defaultOptions;
+    constructor(dialect: Dialect, defaultOptions?: Partial<BatchOptions>);
+    /**
+     * Set default options for batch operations
+     */
+    setDefaultOptions(options: Partial<BatchOptions>): void;
+    /**
+     * Optimize batch insert by combining multiple INSERT statements
+     * @param tableName - Name of the table to insert into
+     * @param records - Array of records to insert
+     * @param options - Batch options
+     */
+    optimizeBatchInsert(tableName: string, records: Record<string, any>[], options?: Partial<BatchOptions>): Promise<BatchResult>;
+    /**
+     * Build the next placeholder token for a bound parameter, given the running
+     * 1-based parameter index. Matches the placeholder convention each dialect's
+     * own buildInsertQuery/buildUpdateQuery/buildDeleteQuery already uses:
+     *   - postgres: $1, $2, ...
+     *   - mssql:    @p1, @p2, ...
+     *   - oracle:   :1, :2, ...
+     *   - others (mysql/mariadb/sqlite): ?
+     */
+    private nextPlaceholder;
+    /**
+     * Execute a batch insert using multi-value INSERT
+     * Uses bound parameters with dialect-correct placeholders ($1, $2, ... for
+     * PostgreSQL, `?` for the other dialects) instead of interpolating values.
+     */
+    private executeBatchInsert;
+    /**
+     * Execute a single record insert
+     */
+    private executeSingleInsert;
+    /**
+     * Optimize batch update
+     * @param tableName - Name of the table to update
+     * @param records - Records to update (must have primary key or unique identifier)
+     * @param identifierColumn - Column to use for identifying records
+     * @param options - Batch options
+     */
+    optimizeBatchUpdate(tableName: string, records: Record<string, any>[], identifierColumn?: string, options?: Partial<BatchOptions>): Promise<BatchResult>;
+    /**
+     * Execute batch update using CASE expressions
+     * Uses bound parameters with dialect-correct placeholders instead of
+     * interpolating escaped literals directly into the SQL string.
+     */
+    private executeBatchUpdate;
+    /**
+     * Execute a single record update
+     */
+    private executeSingleUpdate;
+    /**
+     * Optimize batch delete
+     * @param tableName - Name of the table to delete from
+     * @param identifiers - Array of identifiers for records to delete
+     * @param identifierColumn - Column to use for identifying records
+     * @param options - Batch options
+     */
+    optimizeBatchDelete(tableName: string, identifiers: any[], identifierColumn?: string, options?: Partial<BatchOptions>): Promise<BatchResult>;
+    /**
+     * Execute batch delete using IN clause
+     * Uses bound parameters with dialect-correct placeholders instead of
+     * interpolating escaped literals directly into the SQL string.
+     */
+    private executeBatchDelete;
+    /**
+     * Execute a single record delete
+     */
+    private executeSingleDelete;
+    /**
+     * Check if error is a duplicate key error
+     */
+    private isDuplicateKeyError;
+    /**
+     * Chunk an array into smaller arrays
+     */
+    private chunkArray;
+    /**
+     * Log progress
+     */
+    private logProgress;
+}
+/**
+ * Optimize a batch insert operation
+ */
+export declare function optimizeBatchInsert(dialect: Dialect, tableName: string, records: Record<string, any>[], options?: Partial<BatchOptions>): Promise<BatchResult>;
+/**
+ * Optimize a batch update operation
+ */
+export declare function optimizeBatchUpdate(dialect: Dialect, tableName: string, records: Record<string, any>[], identifierColumn?: string, options?: Partial<BatchOptions>): Promise<BatchResult>;
+/**
+ * Optimize a batch delete operation
+ */
+export declare function optimizeBatchDelete(dialect: Dialect, tableName: string, identifiers: any[], identifierColumn?: string, options?: Partial<BatchOptions>): Promise<BatchResult>;
+declare const _default: {
+    BatchQueryOptimizer: typeof BatchQueryOptimizer;
+    optimizeBatchInsert: typeof optimizeBatchInsert;
+    optimizeBatchUpdate: typeof optimizeBatchUpdate;
+    optimizeBatchDelete: typeof optimizeBatchDelete;
+};
+export default _default;