drizzle-seed 0.3.2-f8a2f3c → 0.4.0-4ec2def

package/index.mjs

@@ -1,9 +1,188 @@
-import { is, entityKind, eq, sql, Relations, getTableName, extractTablesRelationalConfig, createTableRelationsHelpers, One } from 'drizzle-orm';
-import { MySqlDatabase, MySqlTable, getTableConfig as getTableConfig$1 } from 'drizzle-orm/mysql-core';
-import { PgDatabase, getTableConfig, PgTable } from 'drizzle-orm/pg-core';
-import { BaseSQLiteDatabase, SQLiteTable, getTableConfig as getTableConfig$2 } from 'drizzle-orm/sqlite-core';
+import { getTableName, is, getColumnTable, Column, entityKind, sql, eq } from 'drizzle-orm';
+import { MySqlTable, getTableConfig as getTableConfig$2, MySqlDatabase } from 'drizzle-orm/mysql-core';
+import { PgTable, getTableConfig as getTableConfig$1, PgDatabase } from 'drizzle-orm/pg-core';
+import { SQLiteTable, getTableConfig as getTableConfig$3, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { MsSqlTable, getTableConfig as getTableConfig$5, MsSqlDatabase } from 'drizzle-orm/mssql-core';
+import { CockroachTable, getTableConfig as getTableConfig$4, CockroachDatabase } from 'drizzle-orm/cockroach-core';
+import { getTableConfig as getTableConfig$6, SingleStoreDatabase, SingleStoreTable } from 'drizzle-orm/singlestore-core';
+import { extractTablesRelationalConfig, createTableRelationsHelpers, One, Relations } from 'drizzle-orm/_relations';
 import prand from 'pure-rand';
 
+const isRelationCyclic = (startRel) => {
+    // self relation
+    if (startRel.table === startRel.refTable)
+        return false;
+    // DFS
+    const targetTable = startRel.table;
+    const queue = [startRel];
+    let path = [];
+    while (queue.length !== 0) {
+        const currRel = queue.shift();
+        if (path.includes(currRel.table)) {
+            const idx = path.indexOf(currRel.table);
+            path = path.slice(0, idx);
+        }
+        path.push(currRel.table);
+        for (const rel of currRel.refTableRels) {
+            // self relation
+            if (rel.table === rel.refTable)
+                continue;
+            if (rel.refTable === targetTable)
+                return true;
+            // found cycle, but not the one we are looking for
+            if (path.includes(rel.refTable))
+                continue;
+            queue.unshift(rel);
+        }
+    }
+    return false;
+};
+const generateHashFromString = (s) => {
+    let hash = 0;
+    // p and m are prime numbers
+    const p = 53;
+    const m = 28871271685163;
+    for (let i = 0; i < s.length; i++) {
+        hash += ((s.codePointAt(i) || 0) * Math.pow(p, i)) % m;
+    }
+    return hash;
+};
+const equalSets = (set1, set2) => {
+    return set1.size === set2.size && [...set1].every((si) => set2.has(si));
+};
+
+const getTableConfig = (table) => {
+    if (is(table, PgTable))
+        return getTableConfig$1(table);
+    else if (is(table, MySqlTable))
+        return getTableConfig$2(table);
+    else if (is(table, SQLiteTable))
+        return getTableConfig$3(table);
+    else if (is(table, CockroachTable))
+        return getTableConfig$4(table);
+    else if (is(table, MsSqlTable))
+        return getTableConfig$5(table);
+    else
+        return getTableConfig$6(table); // if (is(table, SingleStoreTable))
+};
+const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
+    const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
+    const relations = [];
+    for (const table of Object.values(schemaConfig.tables)) {
+        if (table.relations === undefined)
+            continue;
+        for (const drizzleRel of Object.values(table.relations)) {
+            if (!is(drizzleRel, One))
+                continue;
+            const tableConfig = getTableConfig(drizzleRel.sourceTable);
+            const tableDbSchema = tableConfig.schema ?? 'public';
+            const tableDbName = tableConfig.name;
+            const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
+            const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
+            const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
+                ?? [];
+            const refTableConfig = getTableConfig(drizzleRel.referencedTable);
+            const refTableDbSchema = refTableConfig.schema ?? 'public';
+            const refTableDbName = refTableConfig.name;
+            const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
+                ?? refTableDbName;
+            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
+            const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
+                ?? [];
+            if (tableRelations[refTableTsName] === undefined) {
+                tableRelations[refTableTsName] = [];
+            }
+            const relation = {
+                table: tableTsName,
+                columns,
+                refTable: refTableTsName,
+                refColumns,
+                refTableRels: tableRelations[refTableTsName],
+                type: 'one',
+            };
+            // do not add duplicate relation
+            if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
+                && rel.refTable === relation.refTable)) {
+                console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
+                    + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
+                    + `In this case, the foreign key constraint will be used.\n`);
+                continue;
+            }
+            relations.push(relation);
+            tableRelations[tableTsName].push(relation);
+        }
+    }
+    return relations;
+};
+const getSchemaInfo = (drizzleTablesAndRelations, drizzleTables, mapTable) => {
+    let tableConfig;
+    let dbToTsColumnNamesMap;
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(drizzleTables).map(([key, value]) => [getTableName(value), key]));
+    const tables = [];
+    const relations = [];
+    const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
+    const getDbToTsColumnNamesMap = (table) => {
+        let dbToTsColumnNamesMap = {};
+        const tableName = getTableName(table);
+        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
+            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
+            return dbToTsColumnNamesMap;
+        }
+        const tableConfig = getTableConfig(table);
+        for (const [tsCol, col] of Object.entries(getColumnTable(tableConfig.columns[0]))) {
+            if (is(col, Column))
+                dbToTsColumnNamesMap[col.name] = tsCol;
+        }
+        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
+        return dbToTsColumnNamesMap;
+    };
+    for (const table of Object.values(drizzleTables)) {
+        tableConfig = getTableConfig(table);
+        dbToTsColumnNamesMap = getDbToTsColumnNamesMap(table);
+        // might be empty list
+        const newRelations = tableConfig.foreignKeys === undefined ? [] : tableConfig.foreignKeys.map((fk) => {
+            const table = dbToTsTableNamesMap[tableConfig.name];
+            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
+            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
+            if (tableRelations[refTable] === undefined) {
+                tableRelations[refTable] = [];
+            }
+            return {
+                table,
+                columns: fk
+                    .reference()
+                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
+                refTable,
+                refColumns: fk
+                    .reference()
+                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
+                refTableRels: tableRelations[refTable],
+            };
+        });
+        relations.push(...newRelations);
+        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
+            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
+        }
+        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
+        // console.log(tableConfig.columns);
+        tables.push(mapTable(tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap));
+    }
+    const transformedDrizzleRelations = transformFromDrizzleRelation(drizzleTablesAndRelations, getDbToTsColumnNamesMap, tableRelations);
+    relations.push(...transformedDrizzleRelations);
+    const isCyclicRelations = relations.map((relI) => {
+        // if (relations.some((relj) => relI.table === relj.refTable && relI.refTable === relj.table)) {
+        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
+        if (isRelationCyclic(relI)) {
+            tableRel['isCyclic'] = true;
+            return { ...relI, isCyclic: true };
+        }
+        tableRel['isCyclic'] = false;
+        return { ...relI, isCyclic: false };
+    });
+    return { tables, relations: isCyclicRelations, tableRelations };
+};
+
 /**
  * The original source for the Adjectives data was taken from https://www.kaggle.com/datasets/jordansiem/adjectives-list
  */
@@ -131130,18 +131309,60 @@ var streetSuffix = [
 ];
 const maxStringLength = 10;
 
+/* eslint-disable drizzle-internal/require-entity-kind */
 const fastCartesianProduct = (sets, index) => {
     const resultList = [];
     let currSet;
     let element;
     for (let i = sets.length - 1; i >= 0; i--) {
         currSet = sets[i];
-        element = currSet[index % currSet.length];
+        element = currSet[index % Number(currSet.length)];
         resultList.unshift(element);
-        index = Math.floor(index / currSet.length);
+        index = Math.floor(index / Number(currSet.length));
     }
     return resultList;
 };
+const fastCartesianProductForBigint = (sets, index) => {
+    const resultList = [];
+    let currSet;
+    let element;
+    for (let i = sets.length - 1; i >= 0; i--) {
+        currSet = sets[i];
+        const remainder = index % BigInt(currSet.length);
+        // TODO check how it works
+        // remainder = remainder <= Number.MAX_SAFE_INTEGER ? Number(remainder) : remainder;
+        element = currSet[remainder];
+        resultList.unshift(element);
+        index = index / BigInt(currSet.length);
+    }
+    return resultList;
+};
+class OrderedNumberRange {
+    min;
+    max;
+    step;
+    length;
+    constructor(min, max, step) {
+        this.min = min;
+        this.max = max;
+        this.step = step;
+        this.length = Math.floor((this.max - this.min) / this.step) + 1;
+        const handler = {
+            get(target, prop, receiver) {
+                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                    const idx = Number(prop);
+                    if (idx >= target.length)
+                        return undefined;
+                    return (target.min + idx * target.step);
+                }
+                // fallback to normal lookup (and TS knows this has the right signature)
+                return Reflect.get(target, prop, receiver);
+            },
+        };
+        return new Proxy(this, handler);
+    }
+}
+const abs = (n) => (n < 0n) ? -n : n;
 const sumArray = (weights) => {
     const scale = 1e10;
     const scaledSum = weights.reduce((acc, currVal) => acc + Math.round(currVal * scale), 0);
@@ -131165,16 +131386,6 @@ const getWeightedIndices = (weights, accuracy = 100) => {
     }
     return weightedIndices;
 };
-const generateHashFromString = (s) => {
-    let hash = 0;
-    // p and m are prime numbers
-    const p = 53;
-    const m = 28871271685163;
-    for (let i = 0; i < s.length; i++) {
-        hash += ((s.codePointAt(i) || 0) * Math.pow(p, i)) % m;
-    }
-    return hash;
-};
 /**
  * @param param0.template example: "#####" or "#####-####"
  * @param param0.values example: ["3", "2", "h"]
@@ -131211,12 +131422,27 @@ const isObject = (value) => {
         return true;
     return false;
 };
-const equalSets = (set1, set2) => {
-    return set1.size === set2.size && [...set1].every((si) => set2.has(si));
-};
-const isValidDate = (date) => {
-    return !Number.isNaN(date.getTime());
-};
+// const main = () => {
+// 	console.time('range');
+// 	const range = new OrderedBigintRange(BigInt(-10), BigInt(10), BigInt(1));
+// 	console.log(range.length);
+// 	for (let i = 0; i < Number(range.length) + 1; i++) {
+// 		console.log(range[i]);
+// 	}
+// 	console.timeEnd('range');
+// 	const list = Array.from({ length: 2e6 + 1 }, (_, idx) => idx);
+// 	console.time('list');
+// 	console.log(list.length);
+// 	for (let i = 0; i < 2e6 + 1; i++) {
+// 		list[i];
+// 	}
+// 	console.timeEnd('list');
+// 	// const n = 5;
+// 	// for (let i = 0; i < n; i++) {
+// 	// 	console.log(fastCartesianProduct([[1, 2], [1, 2]], i));
+// 	// }
+// };
+// main();
 
 /* eslint-disable drizzle-internal/require-entity-kind */
 class AbstractGenerator {
@@ -131232,10 +131458,11 @@ class AbstractGenerator {
     arraySize;
     baseColumnDataType;
     // param for text-like generators
-    stringLength;
+    // public stringLength?: number;
     // params for GenerateValuesFromArray
     weightedCountSeed;
     maxRepeatedValuesCount;
+    typeParams = {};
     params;
     constructor(params) {
         this.params = params === undefined ? {} : params;
@@ -131267,6 +131494,7 @@ class AbstractGenerator {
             });
             uniqueGen.isUnique = this.isUnique;
             uniqueGen.dataType = this.dataType;
+            uniqueGen.typeParams = this.typeParams;
             return uniqueGen;
         }
         return;
@@ -131277,10 +131505,13 @@ class AbstractGenerator {
             const uniqueGen = this.replaceIfUnique();
             const baseColumnGen = uniqueGen === undefined ? this : uniqueGen;
             baseColumnGen.dataType = this.baseColumnDataType;
+            const { dimensions, ...rest } = baseColumnGen.typeParams;
+            baseColumnGen.typeParams = rest;
             const arrayGen = new GenerateArray({
                 baseColumnGen,
                 size: this.arraySize,
             });
+            arrayGen.typeParams = { dimensions };
             return arrayGen;
         }
         return;
@@ -131535,6 +131766,7 @@ class GenerateNumber extends AbstractGenerator {
     static entityKind = 'GenerateNumber';
     state;
     uniqueVersionOfGen = GenerateUniqueNumber;
+    // TODO rewrite precision to decimalPlaces
     init({ count, seed }) {
         super.init({ count, seed });
         let { minValue, maxValue, precision } = this.params;
@@ -131788,20 +132020,13 @@ class GenerateDate extends AbstractGenerator {
         const rng = prand.xoroshiro128plus(seed);
         let { minDate, maxDate } = this.params;
         const anchorDate = new Date('2024-05-08');
-        // 4 years in milliseconds
         const deltaMilliseconds = 4 * 31536000000;
         if (typeof minDate === 'string') {
             minDate = new Date(minDate);
         }
-        if (typeof minDate === 'object' && !isValidDate(minDate)) {
-            throw new Error('Invalid Date was provided for the minDate parameter.');
-        }
         if (typeof maxDate === 'string') {
             maxDate = new Date(maxDate);
         }
-        if (typeof maxDate === 'object' && !isValidDate(maxDate)) {
-            throw new Error('Invalid Date was provided for the maxDate parameter.');
-        }
         if (minDate === undefined) {
             if (maxDate === undefined) {
                 minDate = new Date(anchorDate.getTime() - deltaMilliseconds);
@@ -131814,9 +132039,6 @@ class GenerateDate extends AbstractGenerator {
         if (maxDate === undefined) {
             maxDate = new Date(minDate.getTime() + (2 * deltaMilliseconds));
         }
-        if (minDate > maxDate) {
-            throw new Error(`The minDate parameter must be less than or equal to the maxDate parameter.`);
-        }
         this.state = { rng, minDate, maxDate };
     }
     generate() {
@@ -131838,83 +132060,18 @@ class GenerateTime extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        let { minTime, maxTime } = this.params;
-        if (minTime === undefined && maxTime === undefined) {
-            // TODO: maybe need to change in major version release
-            // This is required to ensure that this generator remains deterministic when used without minTime, maxTime parameters.
-            const oneDayInMilliseconds = 86400000;
-            minTime = new Date(new Date('2024-05-08T12:00:00.000Z').getTime() - oneDayInMilliseconds);
-            maxTime = new Date(new Date('2024-05-08T12:00:00.000Z').getTime() + oneDayInMilliseconds);
-            this.state = { rng, minTime, maxTime };
-            return;
-        }
-        if (minTime === undefined) {
-            if (maxTime === undefined) {
-                minTime = '00:00:00.000Z';
-                maxTime = '23:59:59.999Z';
-            }
-            else {
-                minTime = '00:00:00.000Z';
-            }
-        }
-        if (maxTime === undefined) {
-            maxTime = '23:59:59.999Z';
-            new Date().toISOString();
-        }
-        const anchorDate = new Date('2024-05-08');
-        const anchorDateString0 = anchorDate.toISOString().replace(/T\d{2}:\d{2}:\d{2}.\d{3}Z/, '');
-        if (typeof minTime === 'string') {
-            // const timeMatch0 = minTime.match(/^\d{2}:\d{2}:\d{2}.\d{1,3}Z?$/);
-            const timeMatch1 = minTime.match(/^\d{2}:\d{2}:\d{2}Z?$/);
-            const timeMatch2 = minTime.match(/^\d{2}:\d{2}Z?$/);
-            if (
-            // timeMatch0 === null
-            timeMatch1 === null
-                && timeMatch2 === null) {
-                throw new Error(`You're using the wrong format for the minTime parameter.`
-                    + `\nPlease use one of these formats: 'HH:mm:ss', 'HH:mm' (with or without a trailing 'Z')`);
-            }
-            minTime = minTime.at(-1) === 'Z' ? minTime : minTime + 'Z';
-            minTime = new Date(anchorDate.toISOString().replace(/\d{2}:\d{2}:\d{2}.\d{3}Z/, minTime));
-        }
-        if (typeof minTime === 'object') {
-            if (!isValidDate(minTime)) {
-                throw new Error('Invalid Date was provided for the minTime parameter.');
-            }
-            minTime = new Date(minTime.toISOString().replace(/\d{4}-\d{2}-\d{2}/, anchorDateString0));
-        }
-        if (typeof maxTime === 'string') {
-            // const timeMatch0 = maxTime.match(/^\d{2}:\d{2}:\d{2}.\d{1,3}Z?$/);
-            const timeMatch1 = maxTime.match(/^\d{2}:\d{2}:\d{2}Z?$/);
-            const timeMatch2 = maxTime.match(/^\d{2}:\d{2}Z?$/);
-            if (
-            // timeMatch0 === null
-            timeMatch1 === null
-                && timeMatch2 === null) {
-                throw new Error(`You're using the wrong format for the maxTime parameter.`
-                    + `\nPlease use one of these formats: 'HH:mm:ss', 'HH:mm' (with or without a trailing 'Z').`);
-            }
-            maxTime = maxTime.at(-1) === 'Z' ? maxTime : maxTime + 'Z';
-            maxTime = new Date(anchorDate.toISOString().replace(/\d{2}:\d{2}:\d{2}.\d{3}Z/, maxTime));
-        }
-        if (typeof maxTime === 'object') {
-            if (!isValidDate(maxTime)) {
-                throw new Error('Invalid Date was provided for the maxTime parameter.');
-            }
-            maxTime = new Date(maxTime.toISOString().replace(/\d{4}-\d{2}-\d{2}/, anchorDateString0));
-        }
-        if (minTime > maxTime) {
-            throw new Error(`The minTime parameter must be less than or equal to the maxTime parameter.`);
-        }
-        this.state = { rng, minTime, maxTime };
+        this.state = { rng };
     }
     generate() {
         if (this.state === undefined) {
             throw new Error('state is not defined.');
         }
+        const anchorDateTime = new Date('2024-05-08T12:00:00.000Z');
+        const oneDayInMilliseconds = 86400000;
+        let date = new Date();
         let milliseconds;
-        [milliseconds, this.state.rng] = prand.uniformIntDistribution(this.state.minTime.getTime(), this.state.maxTime.getTime(), this.state.rng);
-        const date = new Date(milliseconds);
+        [milliseconds, this.state.rng] = prand.uniformIntDistribution(-oneDayInMilliseconds, oneDayInMilliseconds, this.state.rng);
+        date = new Date(date.setTime(anchorDateTime.getTime() + milliseconds));
         return date.toISOString().replace(/(\d{4}-\d{2}-\d{2}T)|(\.\d{3}Z)/g, '');
     }
 }
@@ -131924,46 +132081,18 @@ class GenerateTimestamp extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        let { minTimestamp, maxTimestamp } = this.params;
-        const anchorDate = new Date('2024-05-08');
-        // 2 years in milliseconds
-        const deltaMilliseconds = 2 * 31536000000;
-        if (typeof minTimestamp === 'string') {
-            minTimestamp = new Date(minTimestamp);
-        }
-        if (typeof minTimestamp === 'object' && !isValidDate(minTimestamp)) {
-            throw new Error('Invalid Date was provided for the minTimestamp parameter.');
-        }
-        if (typeof maxTimestamp === 'string') {
-            maxTimestamp = new Date(maxTimestamp);
-        }
-        if (typeof maxTimestamp === 'object' && !isValidDate(maxTimestamp)) {
-            throw new Error('Invalid Date was provided for the maxTimestamp parameter.');
-        }
-        if (minTimestamp === undefined) {
-            if (maxTimestamp === undefined) {
-                minTimestamp = new Date(anchorDate.getTime() - deltaMilliseconds);
-                maxTimestamp = new Date(anchorDate.getTime() + deltaMilliseconds);
-            }
-            else {
-                minTimestamp = new Date(maxTimestamp.getTime() - (2 * deltaMilliseconds));
-            }
-        }
-        if (maxTimestamp === undefined) {
-            maxTimestamp = new Date(minTimestamp.getTime() + (2 * deltaMilliseconds));
-        }
-        if (minTimestamp > maxTimestamp) {
-            throw new Error(`The minTimestamp parameter must be less than or equal to the maxTimestamp parameter.`);
-        }
-        this.state = { rng, minTimestamp, maxTimestamp };
+        this.state = { rng };
     }
     generate() {
         if (this.state === undefined) {
             throw new Error('state is not defined.');
         }
+        const anchorTimestamp = new Date('2024-05-08');
+        const twoYearsInMilliseconds = 2 * 31536000000;
+        let date = new Date();
         let milliseconds;
-        [milliseconds, this.state.rng] = prand.uniformIntDistribution(this.state.minTimestamp.getTime(), this.state.maxTimestamp.getTime(), this.state.rng);
-        const date = new Date(milliseconds);
+        [milliseconds, this.state.rng] = prand.uniformIntDistribution(-twoYearsInMilliseconds, twoYearsInMilliseconds, this.state.rng);
+        date = new Date(date.setTime(anchorTimestamp.getTime() + milliseconds));
         if (this.dataType === 'string') {
             return date
                 .toISOString()
@@ -131979,46 +132108,18 @@ class GenerateDatetime extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        let { minDatetime, maxDatetime } = this.params;
-        const anchorDate = new Date('2024-05-08');
-        // 2 years in milliseconds
-        const deltaMilliseconds = 2 * 31536000000;
-        if (typeof minDatetime === 'string') {
-            minDatetime = new Date(minDatetime);
-        }
-        if (typeof minDatetime === 'object' && !isValidDate(minDatetime)) {
-            throw new Error('Invalid Date was provided for the minDatetime parameter.');
-        }
-        if (typeof maxDatetime === 'string') {
-            maxDatetime = new Date(maxDatetime);
-        }
-        if (typeof maxDatetime === 'object' && !isValidDate(maxDatetime)) {
-            throw new Error('Invalid Date was provided for the maxDatetime parameter.');
-        }
-        if (minDatetime === undefined) {
-            if (maxDatetime === undefined) {
-                minDatetime = new Date(anchorDate.getTime() - deltaMilliseconds);
-                maxDatetime = new Date(anchorDate.getTime() + deltaMilliseconds);
-            }
-            else {
-                minDatetime = new Date(maxDatetime.getTime() - (2 * deltaMilliseconds));
-            }
-        }
-        if (maxDatetime === undefined) {
-            maxDatetime = new Date(minDatetime.getTime() + (2 * deltaMilliseconds));
-        }
-        if (minDatetime > maxDatetime) {
-            throw new Error(`The minDatetime parameter must be less than or equal to the maxDatetime parameter.`);
-        }
-        this.state = { rng, minDatetime, maxDatetime };
+        this.state = { rng };
     }
     generate() {
         if (this.state === undefined) {
             throw new Error('state is not defined.');
         }
+        const anchorDate = new Date('2024-05-08');
+        const twoYearsInMilliseconds = 2 * 31536000000;
+        let date = new Date();
         let milliseconds;
-        [milliseconds, this.state.rng] = prand.uniformIntDistribution(this.state.minDatetime.getTime(), this.state.maxDatetime.getTime(), this.state.rng);
-        const date = new Date(milliseconds);
+        [milliseconds, this.state.rng] = prand.uniformIntDistribution(-twoYearsInMilliseconds, twoYearsInMilliseconds, this.state.rng);
+        date = new Date(date.setTime(anchorDate.getTime() + milliseconds));
         if (this.dataType === 'string') {
             return date
                 .toISOString()
@@ -132304,6 +132405,8 @@ class GenerateString extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
+        if (this.dataType === 'object')
+            return Buffer.from(currStr);
         return currStr;
     }
 }
@@ -132332,7 +132435,10 @@ class GenerateUniqueString extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
-        return currStr.slice(0, 4) + uniqueStr + currStr.slice(4);
+        currStr = currStr.slice(0, 4) + uniqueStr + currStr.slice(4);
+        if (this.dataType === 'object')
+            return Buffer.from(currStr);
+        return currStr;
     }
 }
 class GenerateUUID extends AbstractGenerator {
@@ -132374,8 +132480,8 @@ class GenerateFirstName extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$5) {
-            throw new Error(`You can't use first name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$5}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$5) {
+            throw new Error(`You can't use first name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$5}.`);
         }
         this.state = { rng };
     }
@@ -132398,8 +132504,8 @@ class GenerateUniqueFirstName extends AbstractGenerator {
         if (count > firstNames.length) {
             throw new Error('count exceeds max number of unique first names.');
         }
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$5) {
-            throw new Error(`You can't use first name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$5}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$5) {
+            throw new Error(`You can't use first name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$5}.`);
         }
         const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: firstNames.length - 1 });
         genIndicesObj.init({ count, seed });
@@ -132422,8 +132528,8 @@ class GenerateLastName extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$3) {
-            throw new Error(`You can't use last name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$3}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$3) {
+            throw new Error(`You can't use last name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$3}.`);
         }
         this.state = { rng };
     }
@@ -132444,8 +132550,8 @@ class GenerateUniqueLastName extends AbstractGenerator {
         if (count > lastNames.length) {
             throw new Error('count exceeds max number of unique last names.');
         }
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$3) {
-            throw new Error(`You can't use last name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$3}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$3) {
+            throw new Error(`You can't use last name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$3}.`);
         }
         const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: lastNames.length - 1 });
         genIndicesObj.init({ count, seed });
@@ -132467,8 +132573,8 @@ class GenerateFullName extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        if (this.stringLength !== undefined && this.stringLength < (maxStringLength$5 + maxStringLength$3 + 1)) {
-            throw new Error(`You can't use full name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$5 + maxStringLength$3 + 1}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < (maxStringLength$5 + maxStringLength$3 + 1)) {
+            throw new Error(`You can't use full name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$5 + maxStringLength$3 + 1}.`);
         }
         this.state = { rng };
     }
@@ -132496,8 +132602,8 @@ class GenerateUniqueFullName extends AbstractGenerator {
         if (count > maxUniqueFullNamesNumber) {
             throw new RangeError(`count exceeds max number of unique full names(${maxUniqueFullNamesNumber}).`);
         }
-        if (this.stringLength !== undefined && this.stringLength < (maxStringLength$5 + maxStringLength$3 + 1)) {
-            throw new Error(`You can't use full name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$5 + maxStringLength$3 + 1}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < (maxStringLength$5 + maxStringLength$3 + 1)) {
+            throw new Error(`You can't use full name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$5 + maxStringLength$3 + 1}.`);
         }
         const rng = prand.xoroshiro128plus(seed);
         const fullnameSet = new Set();
@@ -132540,8 +132646,8 @@ class GenerateEmail extends AbstractGenerator {
             throw new RangeError(`count exceeds max number of unique emails(${maxUniqueEmailsNumber}).`);
         }
         const maxEmailLength = maxStringLength$a + maxStringLength$5 + maxStringLength$6 + 2;
-        if (this.stringLength !== undefined && this.stringLength < maxEmailLength) {
-            throw new Error(`You can't use email generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxEmailLength}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxEmailLength) {
+            throw new Error(`You can't use email generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxEmailLength}.`);
         }
         const arraysToGenerateFrom = [adjectivesArray, namesArray, domainsArray];
         const genIndicesObj = new GenerateUniqueInt({
@@ -132574,8 +132680,8 @@ class GeneratePhoneNumber extends AbstractGenerator {
         const { prefixes, template } = this.params;
         const rng = prand.xoroshiro128plus(seed);
         if (template !== undefined) {
-            if (this.stringLength !== undefined && this.stringLength < template.length) {
-                throw new Error(`Length of phone number template is shorter than db column length restriction: ${this.stringLength}. 
+            if (this.typeParams?.length !== undefined && this.typeParams?.length < template.length) {
+                throw new Error(`Length of phone number template is shorter than db column length restriction: ${this.typeParams?.length}. 
 					Set the maximum string length to at least ${template.length}.`);
             }
             const iterArray = [...template.matchAll(/#/g)];
@@ -132620,8 +132726,8 @@ class GeneratePhoneNumber extends AbstractGenerator {
         }
         const maxPrefixLength = Math.max(...prefixesArray.map((prefix) => prefix.length));
         const maxGeneratedDigits = Math.max(...generatedDigitsNumbers);
-        if (this.stringLength !== undefined && this.stringLength < (maxPrefixLength + maxGeneratedDigits)) {
-            throw new Error(`You can't use phone number generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxPrefixLength + maxGeneratedDigits}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < (maxPrefixLength + maxGeneratedDigits)) {
+            throw new Error(`You can't use phone number generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxPrefixLength + maxGeneratedDigits}.`);
         }
         if (new Set(prefixesArray).size !== prefixesArray.length) {
             throw new Error('prefixes are not unique.');
@@ -132698,8 +132804,8 @@ class GenerateCountry extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$7) {
-            throw new Error(`You can't use country generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$7}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$7) {
+            throw new Error(`You can't use country generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$7}.`);
         }
         this.state = { rng };
     }
@@ -132721,8 +132827,8 @@ class GenerateUniqueCountry extends AbstractGenerator {
         if (count > countries.length) {
             throw new Error('count exceeds max number of unique countries.');
         }
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$7) {
-            throw new Error(`You can't use country generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$7}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$7) {
+            throw new Error(`You can't use country generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$7}.`);
         }
         const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: countries.length - 1 });
         genIndicesObj.init({ count, seed });
@@ -132743,8 +132849,8 @@ class GenerateJobTitle extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$4) {
-            throw new Error(`You can't use job title generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$4}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$4) {
+            throw new Error(`You can't use job title generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$4}.`);
         }
         this.state = { rng };
     }
@@ -132766,8 +132872,8 @@ class GenerateStreetAddress extends AbstractGenerator {
         const rng = prand.xoroshiro128plus(seed);
         const possStreetNames = [firstNames, lastNames];
         const maxStreetAddressLength = 4 + Math.max(maxStringLength$5, maxStringLength$3) + 1 + maxStringLength;
-        if (this.stringLength !== undefined && this.stringLength < maxStreetAddressLength) {
-            throw new Error(`You can't use street address generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStreetAddressLength}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStreetAddressLength) {
+            throw new Error(`You can't use street address generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStreetAddressLength}.`);
         }
         this.state = { rng, possStreetNames };
     }
@@ -132796,8 +132902,8 @@ class GenerateUniqueStreetAddress extends AbstractGenerator {
             throw new RangeError(`count exceeds max number of unique street names(${maxUniqueStreetnamesNumber}).`);
         }
         const maxStreetAddressLength = 4 + Math.max(maxStringLength$5, maxStringLength$3) + 1 + maxStringLength;
-        if (this.stringLength !== undefined && this.stringLength < maxStreetAddressLength) {
-            throw new Error(`You can't use street address generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStreetAddressLength}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStreetAddressLength) {
+            throw new Error(`You can't use street address generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStreetAddressLength}.`);
         }
         const rng = prand.xoroshiro128plus(seed);
         // ["1", "2", ..., "999"]
@@ -132853,8 +132959,8 @@ class GenerateCity extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$9) {
-            throw new Error(`You can't use city generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$9}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$9) {
+            throw new Error(`You can't use city generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$9}.`);
         }
         this.state = { rng };
     }
@@ -132875,8 +132981,8 @@ class GenerateUniqueCity extends AbstractGenerator {
         if (count > cityNames.length) {
             throw new Error('count exceeds max number of unique cities.');
         }
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$9) {
-            throw new Error(`You can't use city generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$9}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$9) {
+            throw new Error(`You can't use city generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$9}.`);
         }
         const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: cityNames.length - 1 });
         genIndicesObj.init({ count, seed });
@@ -132900,8 +133006,8 @@ class GeneratePostcode extends AbstractGenerator {
         const rng = prand.xoroshiro128plus(seed);
         const templates = ['#####', '#####-####'];
         const maxPostcodeLength = Math.max(...templates.map((template) => template.length));
-        if (this.stringLength !== undefined && this.stringLength < maxPostcodeLength) {
-            throw new Error(`You can't use postcode generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxPostcodeLength}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxPostcodeLength) {
+            throw new Error(`You can't use postcode generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxPostcodeLength}.`);
         }
         this.state = { rng, templates };
     }
@@ -132951,8 +133057,8 @@ class GenerateUniquePostcode extends AbstractGenerator {
             },
         ];
         const maxPostcodeLength = Math.max(...templates.map((template) => template.template.length));
-        if (this.stringLength !== undefined && this.stringLength < maxPostcodeLength) {
-            throw new Error(`You can't use postcode generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxPostcodeLength}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxPostcodeLength) {
+            throw new Error(`You can't use postcode generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxPostcodeLength}.`);
         }
         for (const templateObj of templates) {
             templateObj.indicesGen.skipCheck = true;
@@ -132988,8 +133094,8 @@ class GenerateState extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        if (this.stringLength !== undefined && this.stringLength < maxStringLength$1) {
-            throw new Error(`You can't use state generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStringLength$1}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$1) {
+            throw new Error(`You can't use state generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$1}.`);
         }
         this.state = { rng };
     }
@@ -133017,8 +133123,8 @@ class GenerateCompanyName extends AbstractGenerator {
         ];
         // max( { template: '#', placeholdersCount: 1 }, { template: '#, # and #', placeholdersCount: 3 } )
         const maxCompanyNameLength = Math.max(maxStringLength$3 + maxStringLength$8 + 1, 3 * maxStringLength$3 + 7);
-        if (this.stringLength !== undefined && this.stringLength < maxCompanyNameLength) {
-            throw new Error(`You can't use company name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxCompanyNameLength}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxCompanyNameLength) {
+            throw new Error(`You can't use company name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxCompanyNameLength}.`);
         }
         this.state = { rng, templates };
     }
@@ -133062,8 +133168,8 @@ class GenerateUniqueCompanyName extends AbstractGenerator {
         }
         // max( { template: '#', placeholdersCount: 1 }, { template: '#, # and #', placeholdersCount: 3 } )
         const maxCompanyNameLength = Math.max(maxStringLength$3 + maxStringLength$8 + 1, 3 * maxStringLength$3 + 7);
-        if (this.stringLength !== undefined && this.stringLength < maxCompanyNameLength) {
-            throw new Error(`You can't use company name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxCompanyNameLength}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxCompanyNameLength) {
+            throw new Error(`You can't use company name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxCompanyNameLength}.`);
         }
         const rng = prand.xoroshiro128plus(seed);
         // when count reach maxUniqueCompanyNameNumber template will be deleted from array
@@ -133139,8 +133245,8 @@ class GenerateLoremIpsum extends AbstractGenerator {
             this.params.sentencesCount = 1;
         const maxLoremIpsumSentencesLength = maxStringLength$2 * this.params.sentencesCount + this.params.sentencesCount
             - 1;
-        if (this.stringLength !== undefined && this.stringLength < maxLoremIpsumSentencesLength) {
-            throw new Error(`You can't use lorem ipsum generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxLoremIpsumSentencesLength}.`);
+        if (this.typeParams?.length !== undefined && this.typeParams?.length < maxLoremIpsumSentencesLength) {
+            throw new Error(`You can't use lorem ipsum generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxLoremIpsumSentencesLength}.`);
         }
         this.state = { rng };
     }
@@ -133229,7 +133335,7 @@ class GeneratePoint extends AbstractGenerator {
         }
         const x = this.state.xCoordinateGen.generate();
         const y = this.state.yCoordinateGen.generate();
-        if (this.dataType === 'json') {
+        if (this.dataType === 'object') {
             return { x, y };
         }
         else if (this.dataType === 'string') {
@@ -133246,6 +133352,7 @@ class GenerateUniquePoint extends AbstractGenerator {
     state;
     isUnique = true;
     init({ count, seed }) {
+        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique points.
         const xCoordinateGen = new GenerateUniqueNumber({
             minValue: this.params.minXValue,
             maxValue: this.params.maxXValue,
@@ -133266,7 +133373,7 @@ class GenerateUniquePoint extends AbstractGenerator {
         }
         const x = this.state.xCoordinateGen.generate();
         const y = this.state.yCoordinateGen.generate();
-        if (this.dataType === 'json') {
+        if (this.dataType === 'object') {
             return { x, y };
         }
         else if (this.dataType === 'string') {
@@ -133315,7 +133422,7 @@ class GenerateLine extends AbstractGenerator {
             b = this.state.bCoefficientGen.generate();
         }
         const c = this.state.cCoefficientGen.generate();
-        if (this.dataType === 'json') {
+        if (this.dataType === 'object') {
             return { a, b, c };
         }
         else if (this.dataType === 'string') {
@@ -133332,6 +133439,7 @@ class GenerateUniqueLine extends AbstractGenerator {
     state;
     isUnique = true;
     init({ count, seed }) {
+        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique triplets(liens).
         const aCoefficientGen = new GenerateUniqueNumber({
             minValue: this.params.minAValue,
             maxValue: this.params.maxAValue,
@@ -133363,7 +133471,7 @@ class GenerateUniqueLine extends AbstractGenerator {
             b = this.state.bCoefficientGen.generate();
         }
         const c = this.state.cCoefficientGen.generate();
-        if (this.dataType === 'json') {
+        if (this.dataType === 'object') {
             return { a, b, c };
         }
         else if (this.dataType === 'string') {
@@ -133375,6 +133483,397 @@ class GenerateUniqueLine extends AbstractGenerator {
         }
     }
 }
+class GenerateBitString extends AbstractGenerator {
+    static entityKind = 'GenerateBitString';
+    dimensions = 11;
+    state;
+    uniqueVersionOfGen = GenerateUniqueBitString;
+    init({ count, seed }) {
+        super.init({ count, seed });
+        this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
+        let intGen;
+        if (this.dimensions > 53) {
+            const maxValue = (BigInt(2) ** BigInt(this.dimensions)) - BigInt(1);
+            intGen = new GenerateInt({ minValue: BigInt(0), maxValue });
+        }
+        else {
+            // dimensions <= 53
+            const maxValue = Math.pow(2, this.dimensions) - 1;
+            intGen = new GenerateInt({ minValue: 0, maxValue });
+        }
+        intGen.init({ count, seed });
+        this.state = { intGen };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        const bitString = this.state.intGen.generate().toString(2);
+        return bitString.padStart(this.dimensions, '0');
+    }
+}
+class GenerateUniqueBitString extends AbstractGenerator {
+    static entityKind = 'GenerateUniqueBitString';
+    dimensions = 11;
+    state;
+    isUnique = true;
+    init({ count, seed }) {
+        this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
+        let intGen;
+        if (this.dimensions > 53) {
+            const maxValue = (BigInt(2) ** BigInt(this.dimensions)) - BigInt(1);
+            intGen = new GenerateUniqueInt({ minValue: BigInt(0), maxValue });
+        }
+        else {
+            // dimensions <= 53
+            const maxValue = Math.pow(2, this.dimensions) - 1;
+            intGen = new GenerateUniqueInt({ minValue: 0, maxValue });
+        }
+        intGen.init({ count, seed });
+        this.state = { intGen };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        const bitString = this.state.intGen.generate().toString(2);
+        return bitString.padStart(this.dimensions, '0');
+    }
+}
+class GenerateInet extends AbstractGenerator {
+    static entityKind = 'GenerateInet';
+    ipAddress = 'ipv4';
+    includeCidr = true;
+    state;
+    uniqueVersionOfGen = GenerateUniqueInet;
+    init({ count, seed }) {
+        super.init({ count, seed });
+        this.ipAddress = this.params.ipAddress ?? this.ipAddress;
+        this.includeCidr = this.params.includeCidr ?? this.includeCidr;
+        const rng = prand.xoroshiro128plus(seed);
+        this.state = { rng };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        let value;
+        const values = [];
+        let inetVal = '';
+        if (this.ipAddress === 'ipv4') {
+            for (let octet = 0; octet < 4; octet++) {
+                [value, this.state.rng] = prand.uniformIntDistribution(0, 255, this.state.rng);
+                values.push(value.toString());
+            }
+            inetVal += values.join('.');
+            if (this.includeCidr) {
+                [value, this.state.rng] = prand.uniformIntDistribution(0, 32, this.state.rng);
+                inetVal += `/${value}`;
+            }
+            return inetVal;
+        }
+        else {
+            // this.ipAddress === 'ipv6'
+            for (let hextet = 0; hextet < 8; hextet++) {
+                [value, this.state.rng] = prand.uniformIntDistribution(0, 65535, this.state.rng);
+                values.push(value.toString(16));
+            }
+            inetVal += values.join(':');
+            if (this.includeCidr) {
+                [value, this.state.rng] = prand.uniformIntDistribution(0, 128, this.state.rng);
+                inetVal += `/${value}`;
+            }
+            return inetVal;
+        }
+    }
+}
+// TODO: add defaults to js doc
+class GenerateUniqueInet extends AbstractGenerator {
+    static entityKind = 'GenerateUniqueInet';
+    ipAddress = 'ipv4';
+    includeCidr = true;
+    delimiter = '.';
+    state;
+    isUnique = true;
+    init({ count, seed }) {
+        this.ipAddress = this.params.ipAddress ?? this.ipAddress;
+        this.delimiter = this.ipAddress === 'ipv4' ? '.' : ':';
+        this.includeCidr = this.params.includeCidr ?? this.includeCidr;
+        // maxValue - number of combinations for cartesian product: {0…255} × {0…255} × {0…255} × {0…255} × {0…32}
+        // where pattern for ipv4 ip is {0–255}.{0–255}.{0–255}.{0–255}[/{0–32}?]
+        // or number of combinations for cartesian product: {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…128}
+        // where pattern for ipv6 ip is {0-65535}:{0-65535}:{0-65535}:{0-65535}:{0-65535}:{0-65535}:{0-65535}:{0-65535}[/0-128?]
+        let minValue, maxValue;
+        if (this.ipAddress === 'ipv4') {
+            minValue = 0;
+            maxValue = 256 ** 4;
+            if (this.includeCidr) {
+                maxValue = maxValue * 33;
+            }
+        }
+        else {
+            // this.ipAddress === 'ipv6'
+            minValue = BigInt(0);
+            maxValue = BigInt(65535) ** BigInt(8);
+            if (this.includeCidr) {
+                maxValue = maxValue * BigInt(129);
+            }
+        }
+        const indexGen = new GenerateUniqueInt({ minValue, maxValue });
+        indexGen.init({ count, seed });
+        const octetSet = Array.from({ length: 256 }, (_, i) => i.toString());
+        const ipv4PrefixSet = Array.from({ length: 33 }, (_, i) => i.toString());
+        const hextetSet = Array.from({ length: 65536 }, (_, i) => i.toString(16));
+        const ipv6PrefixSet = Array.from({ length: 129 }, (_, i) => i.toString());
+        this.state = { indexGen, octetSet, ipv4PrefixSet, hextetSet, ipv6PrefixSet };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        let inetVal = '';
+        let tokens = [];
+        if (this.ipAddress === 'ipv4') {
+            const sets = Array.from({ length: 4 }).fill(this.state.octetSet);
+            if (this.includeCidr)
+                sets.push(this.state.ipv4PrefixSet);
+            const index = this.state.indexGen.generate();
+            tokens = fastCartesianProduct(sets, index);
+        }
+        else {
+            // this.ipAddress === 'ipv6'
+            const sets = Array.from({ length: 8 }).fill(this.state.hextetSet);
+            if (this.includeCidr)
+                sets.push(this.state.ipv6PrefixSet);
+            const idx = this.state.indexGen.generate();
+            tokens = fastCartesianProductForBigint(sets, idx);
+        }
+        inetVal = this.includeCidr
+            ? tokens.slice(0, -1).join(this.delimiter) + `/${tokens.at(-1)}`
+            : tokens.join(this.delimiter);
+        return inetVal;
+    }
+}
+class GenerateGeometry extends AbstractGenerator {
+    static entityKind = 'GenerateGeometry';
+    type = 'point';
+    srid = 4326;
+    decimalPlaces = 6;
+    state;
+    uniqueVersionOfGen = GenerateUniqueGeometry;
+    init({ count, seed }) {
+        super.init({ count, seed });
+        this.type = this.params.type ?? this.type;
+        this.srid = this.params.srid ?? this.srid;
+        this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+        let minXValue, maxXValue, minYValue, maxYValue, denominator;
+        if (this.type === 'point') {
+            if (this.srid === 4326) {
+                // Degrees (latitude / longitude)
+                denominator = 10 ** this.decimalPlaces;
+                minXValue = -180 * denominator;
+                maxXValue = 180 * denominator;
+                minYValue = -90 * denominator;
+                maxYValue = 90 * denominator;
+            }
+            else {
+                // this.srid === 3857
+                // Meters (projected X / Y)
+                denominator = 1;
+                minXValue = -20026376;
+                maxXValue = 20026376;
+                minYValue = -20048966;
+                maxYValue = 20048966;
+            }
+        }
+        else {
+            throw new Error('geometry generator currently supports only the point type.');
+        }
+        const rng = prand.xoroshiro128plus(seed);
+        this.state = { rng, minXValue, maxXValue, minYValue, maxYValue, denominator };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        let x, y;
+        [x, this.state.rng] = prand.uniformIntDistribution(this.state.minXValue, this.state.maxXValue, this.state.rng);
+        x = x / this.state.denominator;
+        [y, this.state.rng] = prand.uniformIntDistribution(this.state.minYValue, this.state.maxYValue, this.state.rng);
+        y = y / this.state.denominator;
+        if (this.dataType === 'array') {
+            return [x, y];
+        }
+        // this.dataType === 'object'
+        return { x, y };
+    }
+}
+class GenerateUniqueGeometry extends AbstractGenerator {
+    static entityKind = 'GenerateUniqueGeometry';
+    type = 'point';
+    srid = 4326;
+    decimalPlaces = 6;
+    state;
+    isUnique = true;
+    init({ count, seed }) {
+        this.type = this.params.type ?? this.type;
+        this.srid = this.params.srid ?? this.srid;
+        this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+        let minXValue, maxXValue, minYValue, maxYValue, denominator;
+        if (this.type === 'point') {
+            if (this.srid === 4326) {
+                // Degrees (latitude / longitude)
+                denominator = 10 ** this.decimalPlaces;
+                minXValue = -180 * denominator;
+                maxXValue = 180 * denominator;
+                minYValue = -90 * denominator;
+                maxYValue = 90 * denominator;
+            }
+            else {
+                // this.srid === 3857
+                // Meters (projected X / Y)
+                denominator = 1;
+                minXValue = -20026376;
+                maxXValue = 20026376;
+                minYValue = -20048966;
+                maxYValue = 20048966;
+            }
+        }
+        else {
+            throw new Error('geometry generator currently supports only the point type.');
+        }
+        const xRange = new OrderedNumberRange(minXValue, maxXValue, 1);
+        const yRange = new OrderedNumberRange(minYValue, maxYValue, 1);
+        const xySets = [xRange, yRange];
+        const maxCombIdx = BigInt(maxXValue - minXValue + 1) * BigInt(maxYValue - minYValue + 1) - BigInt(1);
+        const indexGen = maxCombIdx <= 2 ** 53
+            ? new GenerateUniqueInt({ minValue: 0, maxValue: Number(maxCombIdx) })
+            : new GenerateUniqueInt({ minValue: BigInt(0), maxValue: maxCombIdx });
+        indexGen.init({ count, seed });
+        this.state = { denominator, indexGen, xySets };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        const idx = this.state.indexGen.generate();
+        let x, y;
+        if (typeof idx === 'number') {
+            [x, y] = fastCartesianProduct(this.state.xySets, idx);
+        }
+        else {
+            // typeof idx === 'bigint'
+            [x, y] = fastCartesianProductForBigint(this.state.xySets, idx);
+        }
+        if (this.dataType === 'array') {
+            return [x, y];
+        }
+        // this.dataType === 'object'
+        return { x, y };
+    }
+}
+class GenerateVector extends AbstractGenerator {
+    static entityKind = 'GenerateVector';
+    // property below should be overridden in init
+    dimensions = 3;
+    minValue = -1000;
+    maxValue = 1000;
+    decimalPlaces = 2;
+    state;
+    uniqueVersionOfGen = GenerateUniqueVector;
+    init({ count, seed }) {
+        super.init({ count, seed });
+        this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+        this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+        this.minValue = this.params.minValue ?? this.minValue;
+        this.maxValue = this.params.maxValue ?? this.maxValue;
+        if (this.minValue > this.maxValue) {
+            throw new Error(`minValue ( ${this.minValue} ) cannot be greater than maxValue ( ${this.maxValue} ).\n`
+                + `Did you forget to pass both minValue and maxValue to the generator's properties?`);
+        }
+        if (this.decimalPlaces < 0) {
+            throw new Error(`decimalPlaces value must be greater than or equal to zero.`);
+        }
+        if (abs(BigInt(this.minValue) * BigInt(10 ** this.decimalPlaces)) > Number.MAX_SAFE_INTEGER
+            || abs(BigInt(this.maxValue) * BigInt(10 ** this.decimalPlaces)) > Number.MAX_SAFE_INTEGER) {
+            console.warn(`vector generator: minValue or maxValue multiplied by 10^decimalPlaces exceeds Number.MAX_SAFE_INTEGER (2^53 -1).\n`
+                + `This overflow may result in less accurate values being generated.`);
+        }
+        // `numberGen` is initialized in the `init` method of `GenerateArray`
+        const numberGen = new GenerateNumber({
+            minValue: this.minValue,
+            maxValue: this.maxValue,
+            precision: 10 ** this.decimalPlaces,
+        });
+        const vectorGen = new GenerateArray({ baseColumnGen: numberGen, size: this.dimensions });
+        vectorGen.init({ count, seed });
+        this.state = { vectorGen };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        const vectorVal = this.state.vectorGen.generate();
+        return vectorVal;
+    }
+}
+class GenerateUniqueVector extends AbstractGenerator {
+    static entityKind = 'GenerateUniqueVector';
+    // property below should be overridden in init
+    dimensions = 3;
+    minValue = -1000;
+    maxValue = 1000;
+    decimalPlaces = 2;
+    state;
+    isUnique = true;
+    init({ count, seed }) {
+        this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+        this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+        const denominator = 10 ** this.decimalPlaces;
+        this.minValue = this.params.minValue ?? this.minValue;
+        this.maxValue = this.params.maxValue ?? this.maxValue;
+        if (this.minValue > this.maxValue) {
+            throw new Error(`minValue ( ${this.minValue} ) cannot be greater than maxValue ( ${this.maxValue} ).\n`
+                + `Did you forget to pass both minValue and maxValue to the generator's properties?`);
+        }
+        if (this.decimalPlaces < 0) {
+            throw new Error(`decimalPlaces value must be greater than or equal to zero.`);
+        }
+        if (abs(BigInt(this.minValue) * BigInt(denominator)) > Number.MAX_SAFE_INTEGER
+            || abs(BigInt(this.maxValue) * BigInt(denominator)) > Number.MAX_SAFE_INTEGER) {
+            console.warn(`vector generator: minValue or maxValue multiplied by 10^decimalPlaces exceeds Number.MAX_SAFE_INTEGER (2^53 -1).\n`
+                + `This overflow may result in less accurate values being generated.`);
+        }
+        const dimensionRange = new OrderedNumberRange(this.minValue * denominator, this.maxValue * denominator, 1);
+        const vectorSets = Array.from({ length: this.dimensions }).fill(dimensionRange);
+        const maxCombIdx = vectorSets.reduce((acc, curr) => acc * BigInt(curr.length), BigInt(1)) - BigInt(1);
+        const indexGen = maxCombIdx <= Number.MAX_SAFE_INTEGER
+            ? new GenerateUniqueInt({ minValue: 0, maxValue: Number(maxCombIdx) })
+            : new GenerateUniqueInt({ minValue: BigInt(0), maxValue: maxCombIdx });
+        indexGen.init({ count, seed });
+        const transformVector = denominator === 1
+            ? (_vector, _denominator) => { }
+            : (vector, denominator) => {
+                for (let i = 0; i < vector.length; i++) {
+                    vector[i] = vector[i] / denominator;
+                }
+                return;
+            };
+        this.state = { indexGen, vectorSets, denominator, transformVector };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        const idx = this.state.indexGen.generate();
+        const vector = typeof idx === 'number'
+            ? fastCartesianProduct(this.state.vectorSets, idx)
+            // typeof idx === 'bigint'
+            : fastCartesianProductForBigint(this.state.vectorSets, idx);
+        this.state.transformVector(vector, this.state.denominator);
+        return vector;
+    }
+}
 
 /* eslint-disable drizzle-internal/require-entity-kind */
 class GenerateUniqueIntervalV2 extends AbstractGenerator {
@@ -133461,8 +133960,8 @@ class GenerateStringV2 extends AbstractGenerator {
         super.init({ count, seed });
         let minStringLength = 7;
         let maxStringLength = 20;
-        if (this.stringLength !== undefined) {
-            maxStringLength = this.stringLength;
+        if (this.typeParams?.length !== undefined) {
+            maxStringLength = this.typeParams?.length;
             if (maxStringLength === 1)
                 minStringLength = maxStringLength;
             if (maxStringLength < minStringLength)
@@ -133484,6 +133983,8 @@ class GenerateStringV2 extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
+        if (this.dataType === 'object')
+            return Buffer.from(currStr);
         return currStr;
     }
 }
@@ -133497,8 +133998,8 @@ class GenerateUniqueStringV2 extends AbstractGenerator {
         let minStringLength = 7;
         let maxStringLength = 20;
         // TODO: revise later
-        if (this.stringLength !== undefined) {
-            maxStringLength = this.stringLength;
+        if (this.typeParams?.length !== undefined) {
+            maxStringLength = this.typeParams?.length;
             if (maxStringLength === 1 || maxStringLength < minStringLength)
                 minStringLength = maxStringLength;
         }
@@ -133522,6 +134023,8 @@ class GenerateUniqueStringV2 extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
+        if (this.dataType === 'object')
+            return Buffer.from(uniqueStr + currStr);
         return uniqueStr + currStr;
     }
 }
@@ -133691,8 +134194,6 @@ const generatorsFuncs = {
     date: createGenerator(GenerateDate),
     /**
      * generates time in 24 hours style.
-     * @param minTime - lower border of range.
-     * @param maxTime - upper border of range.
      * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
      *
      * @example
@@ -133700,7 +134201,7 @@ const generatorsFuncs = {
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
      *    users: {
      *      columns: {
-     *        birthTime: funcs.time({ minTime: "11:12:13.141", maxTime: "15:16:17.181" })
+     *        birthTime: funcs.time()
      *      },
      *    },
      *  }));
@@ -133710,8 +134211,6 @@ const generatorsFuncs = {
     time: createGenerator(GenerateTime),
     /**
      * generates timestamps.
-     * @param minTimestamp - lower border of range.
-     * @param maxTimestamp - upper border of range.
      * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
      *
      * @example
@@ -133719,7 +134218,7 @@ const generatorsFuncs = {
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
      *    orders: {
      *      columns: {
-     *        shippedDate: funcs.timestamp({ minTimestamp: "2025-03-07T11:12:13.141", maxTimestamp: "2025-03-08T15:16:17.181" })
+     *        shippedDate: funcs.timestamp()
      *      },
      *    },
      *  }));
@@ -133729,8 +134228,6 @@ const generatorsFuncs = {
     timestamp: createGenerator(GenerateTimestamp),
     /**
      * generates datetime objects.
-     * @param minDatetime - lower border of range.
-     * @param maxDatetime - upper border of range.
      * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
      *
      * @example
@@ -133738,7 +134235,7 @@ const generatorsFuncs = {
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
      *    orders: {
      *      columns: {
-     *        shippedDate: funcs.datetime({ minDatetime: "2025-03-07T11:12:13.141", maxDatetime: "2025-03-08T15:16:17.181" })
+     *        shippedDate: funcs.datetime()
      *      },
      *    },
      *  }));
@@ -134198,8 +134695,132 @@ const generatorsFuncs = {
      * ```
      */
     weightedRandom: createGenerator(WeightedRandomGenerator),
+    /**
+     * generates bit strings based on specified parameters
+     *
+     * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array (If specified, arrays will be generated).
+     * @param dimensions - desired length of each bit string (e.g., `dimensions = 3` produces values like `'010'`).
+     *
+     * Defaults to the value of the database column bit-length.
+     *
+     * @example
+     * ```ts
+     *  await seed(db, { bitStringTable: schema.bitStringTable }).refine((funcs) => ({
+     * 		bitStringTable: {
+     * 			count,
+     * 			columns: {
+     * 				bit: funcs.bitString({
+     * 					dimensions: 12,
+     * 					isUnique: true
+     * 				}),
+     * 			},
+     * 		},
+     * 	}));
+     * ```
+     */
+    bitString: createGenerator(GenerateBitString),
+    /**
+     * generates ip addresses based on specified parameters
+     *
+     * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array (If specified, arrays will be generated).
+     * @param ipAddress - type of IP address to generate — either "ipv4" or "ipv6".
+     *
+     * Defaults to `'ipv4'`.
+     * @param includeCidr - determines whether generated IPs include a CIDR suffix.
+     *
+     * Defaults to `true`.
+     *
+     * @example
+     * ```ts
+     *  await seed(db, { inetTable: schema.inetTable }).refine((funcs) => ({
+     * 		inetTable: {
+     * 			count,
+     * 			columns: {
+     * 				inet: funcs.inet({
+     * 					ipAddress: 'ipv4',
+     * 					includeCidr: true,
+     * 					isUnique: true
+     * 				}),
+     * 			},
+     * 		},
+     * 	}));
+     * ```
+     */
+    inet: createGenerator(GenerateInet),
+    /**
+     * generates PostGIS geometry objects based on the given parameters.
+     *
+     * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array (If specified, arrays will be generated).
+     * @param type - geometry type to generate; currently only `'point'` is supported.
+     *
+     * Defaults to `'point'`.
+     * @param srid - Spatial Reference System Identifier: determines what type of point will be generated - either `4326` or `3857`.
+     *
+     * Defaults to `4326`.
+     * @param decimalPlaces - number of decimal places for points when `srid` is `4326` (e.g., `decimalPlaces = 3` produces values like `'point(30.723 46.482)'`).
+     *
+     * Defaults to `6`.
+     *
+     * @example
+     * ```ts
+     *  await seed(db, { geometryTable: schema.geometryTable }).refine((funcs) => ({
+     * 		geometryTable: {
+     * 			count,
+     * 			columns: {
+     * 				geometryPointTuple: funcs.geometry({
+     * 					type: 'point',
+     * 					srid: 4326,
+     * 					decimalPlaces: 5,
+     * 					isUnique: true
+     * 				})
+     * 			},
+     * 		},
+     * 	}));
+     * ```
+     */
+    geometry: createGenerator(GenerateGeometry),
+    /**
+     * generates vectors based on the provided parameters.
+     *
+     * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array (If specified, arrays will be generated).
+     * @param decimalPlaces - number of decimal places for each vector element (e.g., `decimalPlaces = 3` produces values like `1.123`).
+     *
+     * Defaults to `2`.
+     * @param dimensions - number of elements in each generated vector (e.g., `dimensions = 3` produces values like `[1,2,3]`).
+     *
+     * Defaults to the value of the database column’s dimensions.
+     * @param minValue - minimum allowed value for each vector element.
+     *
+     * Defaults to `-1000`.
+     * @param maxValue - maximum allowed value for each vector element.
+     *
+     * Defaults to `1000`.
+     *
+     * @example
+     * ```ts
+     *  await seed(db, { vectorTable: schema.vectorTable }).refine((funcs) => ({
+     * 		vectorTable: {
+     * 			count,
+     * 			columns: {
+     * 				vector: funcs.vector({
+     * 					decimalPlaces: 5,
+     * 					dimensions: 12,
+     * 					minValue: -100,
+     * 					maxValue: 100,
+     * 					isUnique: true
+     * 				}),
+     * 			},
+     * 		},
+     * 	}));
+     * ```
+     */
+    vector: createGenerator(GenerateVector),
 };
-// so far, version changes don’t change generator parameters.
+// so far, version changes don’t affect generator parameters.
 const generatorsFuncsV2 = {
     ...generatorsFuncs,
 };
@@ -134357,10 +134978,1085 @@ const generatorsMap = {
     GenerateWeightedCount: [
         GenerateWeightedCount,
     ],
+    GenerateBitString: [
+        GenerateBitString,
+    ],
+    GenerateUniqueBitString: [
+        GenerateUniqueBitString,
+    ],
+    GenerateInet: [
+        GenerateInet,
+    ],
+    GenerateUniqueInet: [
+        GenerateUniqueInet,
+    ],
+    GenerateGeometry: [
+        GenerateGeometry,
+    ],
+    GenerateUniqueGeometry: [
+        GenerateUniqueGeometry,
+    ],
+    GenerateVector: [
+        GenerateVector,
+    ],
+    GenerateUniqueVector: [
+        GenerateUniqueVector,
+    ],
+};
+
+// TODO: revise serial part generators
+const selectGeneratorForCockroachColumn = (table, col) => {
+    const pickGenerator = (table, col) => {
+        // ARRAY
+        if (col.columnType.match(/\[\w*]/g) !== null && col.baseColumn !== undefined) {
+            const baseColumnGen = selectGeneratorForCockroachColumn(table, col.baseColumn);
+            if (baseColumnGen === undefined) {
+                throw new Error(`column with type ${col.baseColumn.columnType} is not supported for now.`);
+            }
+            // const getBaseColumnDataType = (baseColumn: Column) => {
+            // 	if (baseColumn.baseColumn !== undefined) {
+            // 		return getBaseColumnDataType(baseColumn.baseColumn);
+            // 	}
+            // 	return baseColumn.dataType;
+            // };
+            // const baseColumnDataType = getBaseColumnDataType(col.baseColumn);
+            const generator = new generatorsMap.GenerateArray[0]({ baseColumnGen, size: col.size });
+            // generator.baseColumnDataType = baseColumnDataType;
+            return generator;
+        }
+        // ARRAY for studio
+        if (col.columnType.match(/\[\w*]/g) !== null) {
+            // remove dimensions from type
+            const baseColumnType = col.columnType.replace(/\[\w*]/g, '');
+            const baseColumn = {
+                ...col,
+            };
+            baseColumn.columnType = baseColumnType;
+            const baseColumnGen = selectGeneratorForCockroachColumn(table, baseColumn);
+            if (baseColumnGen === undefined) {
+                throw new Error(`column with type ${col.baseColumn.columnType} is not supported for now.`);
+            }
+            let generator = new generatorsMap.GenerateArray[0]({ baseColumnGen });
+            for (let i = 0; i < col.typeParams.dimensions - 1; i++) {
+                generator = new generatorsMap.GenerateArray[0]({ baseColumnGen: generator });
+            }
+            return generator;
+        }
+        // INT ------------------------------------------------------------------------------------------------------------
+        if ((col.columnType === 'int2'
+            || col.columnType === 'int4'
+            || col.columnType.includes('int8'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            return generator;
+        }
+        let minValue;
+        let maxValue;
+        if (col.columnType.startsWith('int')) {
+            if (col.columnType === 'int2') {
+                // 2^16 / 2 - 1, 2 bytes
+                minValue = -32768;
+                maxValue = 32767;
+            }
+            else if (col.columnType === 'int4') {
+                // 2^32 / 2 - 1, 4 bytes
+                minValue = -2147483648;
+                maxValue = 2147483647;
+            }
+            else if (col.columnType.includes('int8')) {
+                if (col.dataType === 'bigint') {
+                    // 2^64 / 2 - 1, 8 bytes
+                    minValue = BigInt('-9223372036854775808');
+                    maxValue = BigInt('9223372036854775807');
+                }
+                else {
+                    // if (col.dataType === 'number')
+                    // if you’re expecting values above 2^31 but below 2^53
+                    minValue = -9007199254740991;
+                    maxValue = 9007199254740991;
+                }
+            }
+        }
+        if (col.columnType.startsWith('int')
+            && !col.columnType.includes('interval')) {
+            const generator = new generatorsMap.GenerateInt[0]({
+                minValue,
+                maxValue,
+            });
+            return generator;
+        }
+        // NUMBER(real, double, decimal, numeric)
+        if (col.columnType.startsWith('real')
+            || col.columnType.startsWith('float')
+            || col.columnType.startsWith('decimal')
+            || col.columnType.startsWith('numeric')) {
+            if (col.typeParams.precision !== undefined) {
+                const precision = col.typeParams.precision;
+                const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+                const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+                const generator = new generatorsMap.GenerateNumber[0]({
+                    minValue: -maxAbsoluteValue,
+                    maxValue: maxAbsoluteValue,
+                    precision: Math.pow(10, scale),
+                });
+                return generator;
+            }
+            const generator = new generatorsMap.GenerateNumber[0]();
+            return generator;
+        }
+        // STRING
+        if ((col.columnType === 'string'
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('char'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateUniqueString[0]();
+            return generator;
+        }
+        if ((col.columnType === 'string'
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('char'))
+            && col.name.toLowerCase().includes('name')) {
+            const generator = new generatorsMap.GenerateFirstName[0]();
+            return generator;
+        }
+        if ((col.columnType === 'string'
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('char'))
+            && col.name.toLowerCase().includes('email')) {
+            const generator = new generatorsMap.GenerateEmail[0]();
+            return generator;
+        }
+        if (col.columnType === 'string'
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('char')) {
+            const generator = new generatorsMap.GenerateString[0]();
+            return generator;
+        }
+        // BIT
+        if (col.columnType.startsWith('bit')) {
+            const generator = new generatorsMap.GenerateBitString[0]();
+            return generator;
+        }
+        // INET
+        if (col.columnType === 'inet') {
+            const generator = new generatorsMap.GenerateInet[0]();
+            return generator;
+        }
+        // geometry(point)
+        if (col.columnType.startsWith('geometry')) {
+            const generator = new generatorsMap.GenerateGeometry[0]();
+            return generator;
+        }
+        // vector
+        if (col.columnType.startsWith('vector')) {
+            const generator = new generatorsMap.GenerateVector[0]();
+            return generator;
+        }
+        // UUID
+        if (col.columnType === 'uuid') {
+            const generator = new generatorsMap.GenerateUUID[0]();
+            return generator;
+        }
+        // BOOL
+        if (col.columnType === 'bool') {
+            const generator = new generatorsMap.GenerateBoolean[0]();
+            return generator;
+        }
+        // DATE, TIME, TIMESTAMP
+        if (col.columnType.includes('date')) {
+            const generator = new generatorsMap.GenerateDate[0]();
+            return generator;
+        }
+        if (col.columnType === 'time') {
+            const generator = new generatorsMap.GenerateTime[0]();
+            return generator;
+        }
+        if (col.columnType.includes('timestamp')) {
+            const generator = new generatorsMap.GenerateTimestamp[0]();
+            return generator;
+        }
+        // JSON, JSONB
+        if (col.columnType === 'json' || col.columnType === 'jsonb') {
+            const generator = new generatorsMap.GenerateJson[0]();
+            return generator;
+        }
+        // if (col.columnType === "jsonb") {
+        //   const generator = new GenerateJsonb({});
+        //   return generator;
+        // }
+        // ENUM
+        if (col.enumValues !== undefined) {
+            const generator = new generatorsMap.GenerateEnum[0]({
+                enumValues: col.enumValues,
+            });
+            return generator;
+        }
+        // INTERVAL
+        if (col.columnType.startsWith('interval')) {
+            if (col.columnType === 'interval') {
+                const generator = new generatorsMap.GenerateInterval[0]();
+                return generator;
+            }
+            const fields = col.columnType.replace('interval ', '');
+            const generator = new generatorsMap.GenerateInterval[0]({ fields });
+            return generator;
+        }
+        if (col.hasDefault && col.default !== undefined) {
+            const generator = new generatorsMap.GenerateDefault[0]({
+                defaultValue: col.default,
+            });
+            return generator;
+        }
+        return;
+    };
+    const generator = pickGenerator(table, col);
+    // set params for base column
+    if (generator !== undefined) {
+        generator.isUnique = col.isUnique;
+        generator.dataType = col.dataType;
+        // generator.stringLength = col.typeParams.length;
+        generator.typeParams = col.typeParams;
+    }
+    return generator;
 };
 
 const latestVersion = 2;
 
+const selectGeneratorForMssqlColumn = (table, col) => {
+    const pickGenerator = (table, col) => {
+        // INT ------------------------------------------------------------------------------------------------------------
+        if (col.columnType.includes('int') && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            return generator;
+        }
+        let minValue;
+        let maxValue;
+        if (col.columnType.includes('int')) {
+            if (col.columnType === 'tinyint') {
+                // 2^8 / 2 - 1, 1 bytes
+                // more like unsigned tinyint
+                minValue = 0;
+                maxValue = 255;
+            }
+            else if (col.columnType === 'smallint') {
+                // 2^16 / 2 - 1, 2 bytes
+                minValue = -32768;
+                maxValue = 32767;
+            }
+            else if (col.columnType === 'int') {
+                // 2^32 / 2 - 1, 4 bytes
+                minValue = -2147483648;
+                maxValue = 2147483647;
+            }
+            else if (col.columnType === 'bigint') {
+                // 2^64 / 2 - 1, 8 bytes
+                minValue = BigInt('-9223372036854775808');
+                maxValue = BigInt('9223372036854775807');
+            }
+            const generator = new generatorsMap.GenerateInt[0]({
+                minValue,
+                maxValue,
+            });
+            return generator;
+        }
+        // NUMBER(real, decimal, numeric, float)
+        if (col.columnType.startsWith('real')
+            || col.columnType.startsWith('decimal')
+            || col.columnType.startsWith('float')
+            || col.columnType.startsWith('numeric')) {
+            if (col.typeParams.precision !== undefined) {
+                const precision = col.typeParams.precision;
+                const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+                const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+                const generator = new generatorsMap.GenerateNumber[0]({
+                    minValue: -maxAbsoluteValue,
+                    maxValue: maxAbsoluteValue,
+                    precision: Math.pow(10, scale),
+                });
+                return generator;
+            }
+            const generator = new generatorsMap.GenerateNumber[0]();
+            return generator;
+        }
+        // STRING
+        if ((col.columnType === 'text'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateUniqueString[0]();
+            return generator;
+        }
+        if ((col.columnType === 'text'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && col.name.toLowerCase().includes('name')) {
+            const generator = new generatorsMap.GenerateFirstName[0]();
+            return generator;
+        }
+        if ((col.columnType === 'text'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && col.name.toLowerCase().includes('email')) {
+            const generator = new generatorsMap.GenerateEmail[0]();
+            return generator;
+        }
+        if (col.columnType === 'text'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary')) {
+            const generator = new generatorsMap.GenerateString[0]();
+            return generator;
+        }
+        // bit
+        if (col.columnType === 'bit') {
+            const generator = new generatorsMap.GenerateBoolean[0]();
+            return generator;
+        }
+        // DATE, TIME, TIMESTAMP, DATETIME, YEAR
+        if (col.columnType.includes('datetime')) {
+            const generator = new generatorsMap.GenerateDatetime[0]();
+            return generator;
+        }
+        if (col.columnType.includes('date')) {
+            const generator = new generatorsMap.GenerateDate[0]();
+            return generator;
+        }
+        if (col.columnType === 'time') {
+            const generator = new generatorsMap.GenerateTime[0]();
+            return generator;
+        }
+        // JSON
+        if (col.columnType === 'json') {
+            const generator = new generatorsMap.GenerateJson[0]();
+            return generator;
+        }
+        if (col.hasDefault && col.default !== undefined) {
+            const generator = new generatorsMap.GenerateDefault[0]({
+                defaultValue: col.default,
+            });
+            return generator;
+        }
+        return;
+    };
+    const generator = pickGenerator(table, col);
+    return generator;
+};
+
+const selectGeneratorForMysqlColumn = (table, col) => {
+    const pickGenerator = (table, col) => {
+        // INT ------------------------------------------------------------------------------------------------------------
+        if ((col.columnType.includes('serial') || col.columnType.includes('int'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            return generator;
+        }
+        let minValue;
+        let maxValue;
+        if (col.columnType === 'serial') {
+            // 2^64 % 2 - 1, 8 bytes
+            minValue = BigInt(0);
+            maxValue = BigInt('9223372036854775807');
+        }
+        else if (col.columnType.includes('int')) {
+            if (col.columnType === 'tinyint') {
+                // 2^8 / 2 - 1, 1 bytes
+                minValue = -128;
+                maxValue = 127;
+            }
+            else if (col.columnType === 'smallint') {
+                // 2^16 / 2 - 1, 2 bytes
+                minValue = -32768;
+                maxValue = 32767;
+            }
+            else if (col.columnType === 'mediumint') {
+                // 2^16 / 2 - 1, 2 bytes
+                minValue = -8388608;
+                maxValue = 8388607;
+            }
+            else if (col.columnType === 'int') {
+                // 2^32 / 2 - 1, 4 bytes
+                minValue = -2147483648;
+                maxValue = 2147483647;
+            }
+            else if (col.columnType === 'bigint') {
+                // 2^64 / 2 - 1, 8 bytes
+                minValue = BigInt('-9223372036854775808');
+                maxValue = BigInt('9223372036854775807');
+            }
+        }
+        if (col.columnType.includes('int')) {
+            const generator = new generatorsMap.GenerateInt[0]({
+                minValue,
+                maxValue,
+            });
+            return generator;
+        }
+        if (col.columnType.includes('serial')) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            generator.maxValue = maxValue;
+            return generator;
+        }
+        // NUMBER(real, double, decimal, float)
+        if (col.columnType.startsWith('real')
+            || col.columnType.startsWith('double')
+            || col.columnType.startsWith('decimal')
+            || col.columnType.startsWith('float')
+            || col.columnType.startsWith('numeric')) {
+            if (col.typeParams.precision !== undefined) {
+                const precision = col.typeParams.precision;
+                const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+                const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+                const generator = new generatorsMap.GenerateNumber[0]({
+                    minValue: -maxAbsoluteValue,
+                    maxValue: maxAbsoluteValue,
+                    precision: Math.pow(10, scale),
+                });
+                return generator;
+            }
+            const generator = new generatorsMap.GenerateNumber[0]();
+            return generator;
+        }
+        // STRING
+        if ((col.columnType === 'text'
+            || col.columnType === 'blob'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateUniqueString[0]();
+            return generator;
+        }
+        if ((col.columnType === 'text'
+            || col.columnType === 'blob'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && col.name.toLowerCase().includes('name')) {
+            const generator = new generatorsMap.GenerateFirstName[0]();
+            return generator;
+        }
+        if ((col.columnType === 'text'
+            || col.columnType === 'blob'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && col.name.toLowerCase().includes('email')) {
+            const generator = new generatorsMap.GenerateEmail[0]();
+            return generator;
+        }
+        if (col.columnType === 'text'
+            || col.columnType === 'blob'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary')) {
+            const generator = new generatorsMap.GenerateString[0]();
+            return generator;
+        }
+        // BOOLEAN
+        if (col.columnType === 'boolean') {
+            const generator = new generatorsMap.GenerateBoolean[0]();
+            return generator;
+        }
+        // DATE, TIME, TIMESTAMP, DATETIME, YEAR
+        if (col.columnType.includes('datetime')) {
+            const generator = new generatorsMap.GenerateDatetime[0]();
+            return generator;
+        }
+        if (col.columnType.includes('date')) {
+            const generator = new generatorsMap.GenerateDate[0]();
+            return generator;
+        }
+        if (col.columnType === 'time') {
+            const generator = new generatorsMap.GenerateTime[0]();
+            return generator;
+        }
+        if (col.columnType.includes('timestamp')) {
+            const generator = new generatorsMap.GenerateTimestamp[0]();
+            return generator;
+        }
+        if (col.columnType === 'year') {
+            const generator = new generatorsMap.GenerateYear[0]();
+            return generator;
+        }
+        // JSON
+        if (col.columnType === 'json') {
+            const generator = new generatorsMap.GenerateJson[0]();
+            return generator;
+        }
+        // ENUM
+        if (col.enumValues !== undefined) {
+            const generator = new generatorsMap.GenerateEnum[0]({
+                enumValues: col.enumValues,
+            });
+            return generator;
+        }
+        if (col.hasDefault && col.default !== undefined) {
+            const generator = new generatorsMap.GenerateDefault[0]({
+                defaultValue: col.default,
+            });
+            return generator;
+        }
+        return;
+    };
+    const generator = pickGenerator(table, col);
+    return generator;
+};
+
+// TODO: revise serial part generators
+const selectGeneratorForPostgresColumn = (table, col) => {
+    const pickGenerator = (table, col) => {
+        // ARRAY
+        if (col.columnType.match(/\[\w*]/g) !== null && col.baseColumn !== undefined) {
+            const baseColumnGen = selectGeneratorForPostgresColumn(table, col.baseColumn);
+            if (baseColumnGen === undefined) {
+                throw new Error(`column with type ${col.baseColumn.columnType} is not supported for now.`);
+            }
+            // const getBaseColumnDataType = (baseColumn: Column) => {
+            // 	if (baseColumn.baseColumn !== undefined) {
+            // 		return getBaseColumnDataType(baseColumn.baseColumn);
+            // 	}
+            // 	return baseColumn.dataType;
+            // };
+            // const baseColumnDataType = getBaseColumnDataType(col.baseColumn);
+            const generator = new generatorsMap.GenerateArray[0]({ baseColumnGen, size: col.size });
+            // generator.baseColumnDataType = baseColumnDataType;
+            return generator;
+        }
+        // ARRAY for studio
+        if (col.columnType.match(/\[\w*]/g) !== null) {
+            // remove dimensions from type
+            const baseColumnType = col.columnType.replace(/\[\w*]/g, '');
+            const baseColumn = {
+                ...col,
+            };
+            baseColumn.columnType = baseColumnType;
+            const baseColumnGen = selectGeneratorForPostgresColumn(table, baseColumn);
+            if (baseColumnGen === undefined) {
+                throw new Error(`column with type ${col.baseColumn.columnType} is not supported for now.`);
+            }
+            let generator = new generatorsMap.GenerateArray[0]({ baseColumnGen });
+            for (let i = 0; i < col.typeParams.dimensions - 1; i++) {
+                generator = new generatorsMap.GenerateArray[0]({ baseColumnGen: generator });
+            }
+            return generator;
+        }
+        // INT ------------------------------------------------------------------------------------------------------------
+        if ((col.columnType.includes('serial')
+            || col.columnType === 'integer'
+            || col.columnType === 'smallint'
+            || col.columnType.includes('bigint'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            return generator;
+        }
+        let minValue;
+        let maxValue;
+        if (col.columnType.includes('serial')) {
+            minValue = 1;
+            if (col.columnType === 'smallserial') {
+                // 2^16 / 2 - 1, 2 bytes
+                maxValue = 32767;
+            }
+            else if (col.columnType === 'serial') {
+                // 2^32 / 2 - 1, 4 bytes
+                maxValue = 2147483647;
+            }
+            else if (col.columnType === 'bigserial') {
+                // 2^64 / 2 - 1, 8 bytes
+                minValue = BigInt(1);
+                maxValue = BigInt('9223372036854775807');
+            }
+        }
+        else if (col.columnType.includes('int')) {
+            if (col.columnType === 'smallint') {
+                // 2^16 / 2 - 1, 2 bytes
+                minValue = -32768;
+                maxValue = 32767;
+            }
+            else if (col.columnType === 'integer') {
+                // 2^32 / 2 - 1, 4 bytes
+                minValue = -2147483648;
+                maxValue = 2147483647;
+            }
+            else if (col.columnType.includes('bigint')) {
+                if (col.dataType === 'bigint') {
+                    // 2^64 / 2 - 1, 8 bytes
+                    minValue = BigInt('-9223372036854775808');
+                    maxValue = BigInt('9223372036854775807');
+                }
+                else {
+                    // if (col.dataType === 'number')
+                    // if you’re expecting values above 2^31 but below 2^53
+                    minValue = -9007199254740991;
+                    maxValue = 9007199254740991;
+                }
+            }
+        }
+        if (col.columnType.includes('int')
+            && !col.columnType.includes('interval')
+            && !col.columnType.includes('point')) {
+            const generator = new generatorsMap.GenerateInt[0]({
+                minValue,
+                maxValue,
+            });
+            return generator;
+        }
+        if (col.columnType.includes('serial')) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            generator.maxValue = maxValue;
+            return generator;
+        }
+        // NUMBER(real, double, decimal, numeric)
+        if (col.columnType.startsWith('real')
+            || col.columnType.startsWith('double precision')
+            || col.columnType.startsWith('decimal')
+            || col.columnType.startsWith('numeric')) {
+            if (col.typeParams.precision !== undefined) {
+                const precision = col.typeParams.precision;
+                const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+                const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+                const generator = new generatorsMap.GenerateNumber[0]({
+                    minValue: -maxAbsoluteValue,
+                    maxValue: maxAbsoluteValue,
+                    precision: Math.pow(10, scale),
+                });
+                return generator;
+            }
+            const generator = new generatorsMap.GenerateNumber[0]();
+            return generator;
+        }
+        // STRING
+        if ((col.columnType === 'text'
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('char'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateUniqueString[0]();
+            return generator;
+        }
+        if ((col.columnType === 'text'
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('char'))
+            && col.name.toLowerCase().includes('name')) {
+            const generator = new generatorsMap.GenerateFirstName[0]();
+            return generator;
+        }
+        if ((col.columnType === 'text'
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('char'))
+            && col.name.toLowerCase().includes('email')) {
+            const generator = new generatorsMap.GenerateEmail[0]();
+            return generator;
+        }
+        if (col.columnType === 'text'
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('char')) {
+            const generator = new generatorsMap.GenerateString[0]();
+            return generator;
+        }
+        // BIT
+        if (col.columnType.startsWith('bit')) {
+            const generator = new generatorsMap.GenerateBitString[0]();
+            return generator;
+        }
+        // INET
+        if (col.columnType === 'inet') {
+            const generator = new generatorsMap.GenerateInet[0]();
+            return generator;
+        }
+        // geometry(point)
+        if (col.columnType.startsWith('geometry')) {
+            const generator = new generatorsMap.GenerateGeometry[0]();
+            return generator;
+        }
+        // vector
+        if (col.columnType.startsWith('vector')) {
+            const generator = new generatorsMap.GenerateVector[0]();
+            return generator;
+        }
+        // UUID
+        if (col.columnType === 'uuid') {
+            const generator = new generatorsMap.GenerateUUID[0]();
+            return generator;
+        }
+        // BOOLEAN
+        if (col.columnType === 'boolean') {
+            const generator = new generatorsMap.GenerateBoolean[0]();
+            return generator;
+        }
+        // DATE, TIME, TIMESTAMP
+        if (col.columnType.includes('date')) {
+            const generator = new generatorsMap.GenerateDate[0]();
+            return generator;
+        }
+        if (col.columnType === 'time') {
+            const generator = new generatorsMap.GenerateTime[0]();
+            return generator;
+        }
+        if (col.columnType.includes('timestamp')) {
+            const generator = new generatorsMap.GenerateTimestamp[0]();
+            return generator;
+        }
+        // JSON, JSONB
+        if (col.columnType === 'json' || col.columnType === 'jsonb') {
+            const generator = new generatorsMap.GenerateJson[0]();
+            return generator;
+        }
+        // if (col.columnType === "jsonb") {
+        //   const generator = new GenerateJsonb({});
+        //   return generator;
+        // }
+        // ENUM
+        if (col.enumValues !== undefined) {
+            const generator = new generatorsMap.GenerateEnum[0]({
+                enumValues: col.enumValues,
+            });
+            return generator;
+        }
+        // INTERVAL
+        if (col.columnType.startsWith('interval')) {
+            if (col.columnType === 'interval') {
+                const generator = new generatorsMap.GenerateInterval[0]();
+                return generator;
+            }
+            const fields = col.columnType.replace('interval ', '');
+            const generator = new generatorsMap.GenerateInterval[0]({ fields });
+            return generator;
+        }
+        // POINT, LINE
+        if (col.columnType.includes('point')) {
+            const generator = new generatorsMap.GeneratePoint[0]();
+            return generator;
+        }
+        if (col.columnType.includes('line')) {
+            const generator = new generatorsMap.GenerateLine[0]();
+            return generator;
+        }
+        if (col.hasDefault && col.default !== undefined) {
+            const generator = new generatorsMap.GenerateDefault[0]({
+                defaultValue: col.default,
+            });
+            return generator;
+        }
+        return;
+    };
+    const generator = pickGenerator(table, col);
+    if (generator !== undefined) {
+        generator.isUnique = col.isUnique;
+        generator.dataType = col.dataType;
+        generator.typeParams = col.typeParams;
+        // generator.stringLength = col.typeParams.length;
+    }
+    return generator;
+};
+
+const selectGeneratorForSingleStoreColumn = (table, col) => {
+    const pickGenerator = (table, col) => {
+        // INT ------------------------------------------------------------------------------------------------------------
+        if ((col.columnType.includes('serial') || col.columnType.includes('int'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            return generator;
+        }
+        let minValue;
+        let maxValue;
+        if (col.columnType === 'serial') {
+            // 2^64 % 2 - 1, 8 bytes
+            minValue = BigInt(0);
+            maxValue = BigInt('9223372036854775807');
+        }
+        else if (col.columnType.includes('int')) {
+            if (col.columnType === 'tinyint') {
+                // 2^8 / 2 - 1, 1 bytes
+                minValue = -128;
+                maxValue = 127;
+            }
+            else if (col.columnType === 'smallint') {
+                // 2^16 / 2 - 1, 2 bytes
+                minValue = -32768;
+                maxValue = 32767;
+            }
+            else if (col.columnType === 'mediumint') {
+                // 2^16 / 2 - 1, 2 bytes
+                minValue = -8388608;
+                maxValue = 8388607;
+            }
+            else if (col.columnType === 'int') {
+                // 2^32 / 2 - 1, 4 bytes
+                minValue = -2147483648;
+                maxValue = 2147483647;
+            }
+            else if (col.columnType === 'bigint') {
+                // 2^64 / 2 - 1, 8 bytes
+                minValue = BigInt('-9223372036854775808');
+                maxValue = BigInt('9223372036854775807');
+            }
+        }
+        if (col.columnType.includes('int')) {
+            const generator = new generatorsMap.GenerateInt[0]({
+                minValue,
+                maxValue,
+            });
+            return generator;
+        }
+        if (col.columnType.includes('serial')) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            generator.maxValue = maxValue;
+            return generator;
+        }
+        // NUMBER(real, double, decimal, float)
+        if (col.columnType.startsWith('real')
+            || col.columnType.startsWith('double')
+            || col.columnType.startsWith('decimal')
+            || col.columnType.startsWith('float')
+            || col.columnType.startsWith('numeric')) {
+            if (col.typeParams.precision !== undefined) {
+                const precision = col.typeParams.precision;
+                const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+                const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+                const generator = new generatorsMap.GenerateNumber[0]({
+                    minValue: -maxAbsoluteValue,
+                    maxValue: maxAbsoluteValue,
+                    precision: Math.pow(10, scale),
+                });
+                return generator;
+            }
+            const generator = new generatorsMap.GenerateNumber[0]();
+            return generator;
+        }
+        // STRING
+        if ((col.columnType === 'tinytext'
+            || col.columnType === 'mediumtext'
+            || col.columnType === 'text'
+            || col.columnType === 'longtext'
+            || col.columnType === 'blob'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateUniqueString[0]();
+            return generator;
+        }
+        if ((col.columnType === 'tinytext'
+            || col.columnType === 'mediumtext'
+            || col.columnType === 'text'
+            || col.columnType === 'longtext'
+            || col.columnType === 'blob'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && col.name.toLowerCase().includes('name')) {
+            const generator = new generatorsMap.GenerateFirstName[0]();
+            return generator;
+        }
+        if ((col.columnType === 'tinytext'
+            || col.columnType === 'mediumtext'
+            || col.columnType === 'text'
+            || col.columnType === 'longtext'
+            || col.columnType === 'blob'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary'))
+            && col.name.toLowerCase().includes('email')) {
+            const generator = new generatorsMap.GenerateEmail[0]();
+            return generator;
+        }
+        if (col.columnType === 'tinytext'
+            || col.columnType === 'mediumtext'
+            || col.columnType === 'text'
+            || col.columnType === 'longtext'
+            || col.columnType === 'blob'
+            || col.columnType.startsWith('char')
+            || col.columnType.startsWith('varchar')
+            || col.columnType.startsWith('binary')
+            || col.columnType.startsWith('varbinary')) {
+            const generator = new generatorsMap.GenerateString[0]();
+            return generator;
+        }
+        // BOOLEAN
+        if (col.columnType === 'boolean') {
+            const generator = new generatorsMap.GenerateBoolean[0]();
+            return generator;
+        }
+        // DATE, TIME, TIMESTAMP, DATETIME, YEAR
+        if (col.columnType.includes('datetime')) {
+            const generator = new generatorsMap.GenerateDatetime[0]();
+            return generator;
+        }
+        if (col.columnType.includes('date')) {
+            const generator = new generatorsMap.GenerateDate[0]();
+            return generator;
+        }
+        if (col.columnType === 'time') {
+            const generator = new generatorsMap.GenerateTime[0]();
+            return generator;
+        }
+        if (col.columnType.includes('timestamp')) {
+            const generator = new generatorsMap.GenerateTimestamp[0]();
+            return generator;
+        }
+        if (col.columnType === 'year') {
+            const generator = new generatorsMap.GenerateYear[0]();
+            return generator;
+        }
+        // JSON
+        if (col.columnType === 'json') {
+            const generator = new generatorsMap.GenerateJson[0]();
+            return generator;
+        }
+        // ENUM
+        if (col.enumValues !== undefined) {
+            const generator = new generatorsMap.GenerateEnum[0]({
+                enumValues: col.enumValues,
+            });
+            return generator;
+        }
+        // vector
+        if (col.columnType.startsWith('vector')) {
+            let minValue, maxValue, decimalPlaces;
+            if (col.typeParams.vectorValueType === 'I8') {
+                minValue = -128;
+                maxValue = 127;
+                decimalPlaces = 0;
+            }
+            else if (col.typeParams.vectorValueType === 'I16') {
+                minValue = -32768;
+                maxValue = 32767;
+                decimalPlaces = 0;
+            }
+            else if (col.typeParams.vectorValueType === 'I32') {
+                minValue = -2147483648;
+                maxValue = 2147483647;
+                decimalPlaces = 0;
+            }
+            else if (col.typeParams.vectorValueType === 'I64') {
+                minValue = Number.MIN_SAFE_INTEGER;
+                maxValue = Number.MAX_SAFE_INTEGER;
+                // minValue = -BigInt('9223372036854775808');
+                // maxValue = BigInt('9223372036854775807');
+                decimalPlaces = 0;
+            }
+            else if (col.typeParams.vectorValueType === 'F32') {
+                minValue = -2147483648;
+                maxValue = 2147483647;
+                decimalPlaces = 6;
+            }
+            else if (col.typeParams.vectorValueType === 'F64') {
+                minValue = -524288;
+                maxValue = 524287;
+                decimalPlaces = 10;
+            }
+            const generator = new generatorsMap.GenerateVector[0]({ minValue, maxValue, decimalPlaces });
+            return generator;
+        }
+        if (col.hasDefault && col.default !== undefined) {
+            const generator = new generatorsMap.GenerateDefault[0]({
+                defaultValue: col.default,
+            });
+            return generator;
+        }
+        return;
+    };
+    const generator = pickGenerator(table, col);
+    return generator;
+};
+
+const selectGeneratorForSqlite = (table, col) => {
+    const pickGenerator = (table, col) => {
+        // int section ---------------------------------------------------------------------------------------
+        if ((col.columnType === 'integer' || col.columnType === 'numeric')
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+            return generator;
+        }
+        if (col.columnType === 'integer' && col.dataType === 'boolean') {
+            const generator = new generatorsMap.GenerateBoolean[0]();
+            return generator;
+        }
+        if ((col.columnType === 'integer' && col.dataType === 'object')) {
+            const generator = new generatorsMap.GenerateTimestamp[0]();
+            return generator;
+        }
+        if (col.columnType === 'integer'
+            || (col.dataType === 'bigint' && col.columnType === 'blob')) {
+            const generator = new generatorsMap.GenerateInt[0]();
+            return generator;
+        }
+        // number section ------------------------------------------------------------------------------------
+        if (col.columnType.startsWith('real') || col.columnType.startsWith('numeric')) {
+            if (col.typeParams.precision !== undefined) {
+                const precision = col.typeParams.precision;
+                const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+                const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+                const generator = new generatorsMap.GenerateNumber[0]({
+                    minValue: -maxAbsoluteValue,
+                    maxValue: maxAbsoluteValue,
+                    precision: Math.pow(10, scale),
+                });
+                return generator;
+            }
+            const generator = new generatorsMap.GenerateNumber[0]();
+            return generator;
+        }
+        // string section ------------------------------------------------------------------------------------
+        if ((col.columnType.startsWith('text')
+            || col.columnType.startsWith('numeric')
+            || col.columnType.startsWith('blob'))
+            && table.primaryKeys.includes(col.name)) {
+            const generator = new generatorsMap.GenerateUniqueString[0]();
+            return generator;
+        }
+        if ((col.columnType.startsWith('text')
+            || col.columnType.startsWith('numeric')
+            || col.columnType.startsWith('blob'))
+            && col.name.toLowerCase().includes('name')) {
+            const generator = new generatorsMap.GenerateFirstName[0]();
+            return generator;
+        }
+        if ((col.columnType.startsWith('text')
+            || col.columnType.startsWith('numeric')
+            || col.columnType.startsWith('blob'))
+            && col.name.toLowerCase().includes('email')) {
+            const generator = new generatorsMap.GenerateEmail[0]();
+            return generator;
+        }
+        if (col.columnType.startsWith('text')
+            || col.columnType.startsWith('numeric')
+            || col.columnType.startsWith('blob')
+            || col.columnType.startsWith('blobbuffer')) {
+            const generator = new generatorsMap.GenerateString[0]();
+            return generator;
+        }
+        if ((col.columnType.startsWith('text') && col.dataType === 'json')
+            || (col.columnType.startsWith('blob') && col.dataType === 'json')) {
+            const generator = new generatorsMap.GenerateJson[0]();
+            return generator;
+        }
+        if (col.hasDefault && col.default !== undefined) {
+            const generator = new generatorsMap.GenerateDefault[0]({
+                defaultValue: col.default,
+            });
+            return generator;
+        }
+        return;
+    };
+    const generator = pickGenerator(table, col);
+    return generator;
+};
+
 /* eslint-disable drizzle-internal/require-entity-kind */
 class SeedService {
     static entityKind = 'SeedService';
@@ -134371,6 +136067,7 @@ class SeedService {
     mysqlMaxParametersNumber = 100000;
     //  SQLITE_MAX_VARIABLE_NUMBER, which by default equals to 999 for SQLite versions prior to 3.32.0 (2020-05-22) or 32766 for SQLite versions after 3.32.0.
     sqliteMaxParametersNumber = 32766;
+    mssqlMaxParametersNumber = 2100;
     version;
     generatePossibleGenerators = (connectionType, tables, relations, refinements, options) => {
         let columnPossibleGenerator;
@@ -134410,7 +136107,6 @@ class SeedService {
                     };
                 }
             }
-            // handling refinements (count, with)
             if (refinements !== undefined && refinements[table.name] !== undefined) {
                 if (refinements[table.name].count !== undefined) {
                     tablesPossibleGenerators[i].count = refinements[table.name].count;
@@ -134466,29 +136162,17 @@ class SeedService {
                     notNull: col.notNull,
                     primary: col.primary,
                     generatedIdentityType: col.generatedIdentityType,
+                    identity: col.identity,
                     generator: undefined,
                     isCyclic: false,
                     wasDefinedBefore: false,
                     wasRefined: false,
                 };
-                // handling refinements (columnGenerator)
                 if (refinements !== undefined
                     && refinements[table.name] !== undefined
                     && refinements[table.name].columns !== undefined
                     && refinements[table.name].columns[col.name] !== undefined) {
                     const genObj = refinements[table.name].columns[col.name];
-                    if (genObj === false) {
-                        if (col.notNull === true && col.hasDefault === false) {
-                            throw new Error(`You cannot set the '${col.name}' column in the '${table.name}' table to false in your refinements.`
-                                + `\nDoing so will result in a null value being inserted into the '${col.name}' column,`
-                                + `\nwhich will cause an error because the column has a not null constraint and no default value.`);
-                        }
-                        // Generating undefined as a value for a column and then inserting it via drizzle-orm
-                        // will result in the value not being inserted into that column.
-                        columnPossibleGenerator.generator = new generatorsMap.GenerateDefault[0]({ defaultValue: undefined });
-                        columnPossibleGenerator.wasRefined = true;
-                        continue;
-                    }
                     if (col.columnType.match(/\[\w*]/g) !== null) {
                         if ((col.baseColumn?.dataType === 'array' && col.baseColumn.columnType.match(/\[\w*]/g) !== null)
                             // studio case
@@ -134534,17 +136218,27 @@ class SeedService {
                     }
                 } // TODO: rewrite pickGeneratorFor... using new col properties: isUnique and notNull
                 else if (connectionType === 'postgresql') {
-                    columnPossibleGenerator.generator = this.selectGeneratorForPostgresColumn(table, col);
+                    columnPossibleGenerator.generator = selectGeneratorForPostgresColumn(table, col);
                 }
                 else if (connectionType === 'mysql') {
-                    columnPossibleGenerator.generator = this.selectGeneratorForMysqlColumn(table, col);
+                    columnPossibleGenerator.generator = selectGeneratorForMysqlColumn(table, col);
                 }
                 else if (connectionType === 'sqlite') {
-                    columnPossibleGenerator.generator = this.selectGeneratorForSqlite(table, col);
+                    columnPossibleGenerator.generator = selectGeneratorForSqlite(table, col);
+                }
+                else if (connectionType === 'mssql') {
+                    columnPossibleGenerator.generator = selectGeneratorForMssqlColumn(table, col);
+                }
+                else if (connectionType === 'cockroach') {
+                    columnPossibleGenerator.generator = selectGeneratorForCockroachColumn(table, col);
+                }
+                else if (connectionType === 'singlestore') {
+                    columnPossibleGenerator.generator = selectGeneratorForSingleStoreColumn(table, col);
                 }
                 if (columnPossibleGenerator.generator === undefined) {
                     throw new Error(`column with type ${col.columnType} is not supported for now.`);
                 }
+                columnPossibleGenerator.generator.typeParams = col.typeParams ?? columnPossibleGenerator.generator.typeParams;
                 const arrayGen = columnPossibleGenerator.generator.replaceIfArray();
                 if (arrayGen !== undefined) {
                     columnPossibleGenerator.generator = arrayGen;
@@ -134559,7 +136253,7 @@ class SeedService {
                 // TODO: for now only GenerateValuesFromArray support notNull property
                 columnPossibleGenerator.generator.notNull = col.notNull;
                 columnPossibleGenerator.generator.dataType = col.dataType;
-                columnPossibleGenerator.generator.stringLength = col.typeParams.length;
+                // columnPossibleGenerator.generator.stringLength = col.typeParams.length;
                 tablePossibleGenerators.columnsPossibleGenerators.push(columnPossibleGenerator);
             }
         }
@@ -134570,7 +136264,7 @@ class SeedService {
         if (entityKind === 'GenerateArray') {
             const oldBaseColumnGen = generator.params.baseColumnGen;
             const newBaseColumnGen = this.selectVersionOfGenerator(oldBaseColumnGen);
-            // newGenerator.baseColumnDataType = oldGenerator.baseColumnDataType;
+            newBaseColumnGen.typeParams = oldBaseColumnGen.typeParams;
             generator.params.baseColumnGen = newBaseColumnGen;
         }
         const possibleGeneratorConstructors = generatorsMap[entityKind];
@@ -134586,7 +136280,8 @@ class SeedService {
         // TODO: for now only GenerateValuesFromArray support notNull property
         newGenerator.notNull = generator.notNull;
         newGenerator.dataType = generator.dataType;
-        newGenerator.stringLength = generator.stringLength;
+        // newGenerator.stringLength = generator.stringLength;
+        newGenerator.typeParams = generator.typeParams ?? newGenerator.typeParams;
         return newGenerator;
     };
     cyclicTablesCompare = (table1, table2, relation, reverseRelation) => {
@@ -134697,474 +136392,6 @@ class SeedService {
         }
         return weightedWithCount;
     };
-    // TODO: revise serial part generators
-    selectGeneratorForPostgresColumn = (table, col) => {
-        const pickGenerator = (table, col) => {
-            // ARRAY
-            if (col.columnType.match(/\[\w*]/g) !== null && col.baseColumn !== undefined) {
-                const baseColumnGen = this.selectGeneratorForPostgresColumn(table, col.baseColumn);
-                if (baseColumnGen === undefined) {
-                    throw new Error(`column with type ${col.baseColumn.columnType} is not supported for now.`);
-                }
-                // const getBaseColumnDataType = (baseColumn: Column) => {
-                // 	if (baseColumn.baseColumn !== undefined) {
-                // 		return getBaseColumnDataType(baseColumn.baseColumn);
-                // 	}
-                // 	return baseColumn.dataType;
-                // };
-                // const baseColumnDataType = getBaseColumnDataType(col.baseColumn);
-                const generator = new generatorsMap.GenerateArray[0]({ baseColumnGen, size: col.size });
-                // generator.baseColumnDataType = baseColumnDataType;
-                return generator;
-            }
-            // ARRAY for studio
-            if (col.columnType.match(/\[\w*]/g) !== null) {
-                // remove dimensions from type
-                const baseColumnType = col.columnType.replace(/\[\w*]/g, '');
-                const baseColumn = {
-                    ...col,
-                };
-                baseColumn.columnType = baseColumnType;
-                const baseColumnGen = this.selectGeneratorForPostgresColumn(table, baseColumn);
-                if (baseColumnGen === undefined) {
-                    throw new Error(`column with type ${col.baseColumn.columnType} is not supported for now.`);
-                }
-                let generator = new generatorsMap.GenerateArray[0]({ baseColumnGen });
-                for (let i = 0; i < col.typeParams.dimensions - 1; i++) {
-                    generator = new generatorsMap.GenerateArray[0]({ baseColumnGen: generator });
-                }
-                return generator;
-            }
-            // INT ------------------------------------------------------------------------------------------------------------
-            if ((['smallserial', 'serial', 'bigserial'].includes(col.columnType)
-                || ['smallint', 'integer', 'bigint'].includes(col.columnType))
-                && table.primaryKeys.includes(col.name)) {
-                const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-                return generator;
-            }
-            let minValue;
-            let maxValue;
-            if (['smallserial', 'serial', 'bigserial'].includes(col.columnType)) {
-                minValue = 1;
-                if (col.columnType === 'smallserial') {
-                    // 2^16 / 2 - 1, 2 bytes
-                    maxValue = 32767;
-                }
-                else if (col.columnType === 'serial') {
-                    // 2^32 / 2 - 1, 4 bytes
-                    maxValue = 2147483647;
-                }
-                else if (col.columnType === 'bigserial') {
-                    // 2^64 / 2 - 1, 8 bytes
-                    minValue = BigInt(1);
-                    maxValue = BigInt('9223372036854775807');
-                }
-            }
-            else if (['smallint', 'integer', 'bigint'].includes(col.columnType)) {
-                if (col.columnType === 'smallint') {
-                    // 2^16 / 2 - 1, 2 bytes
-                    minValue = -32768;
-                    maxValue = 32767;
-                }
-                else if (col.columnType === 'integer') {
-                    // 2^32 / 2 - 1, 4 bytes
-                    minValue = -2147483648;
-                    maxValue = 2147483647;
-                }
-                else if (col.columnType.includes('bigint')) {
-                    if (col.dataType === 'bigint') {
-                        // 2^64 / 2 - 1, 8 bytes
-                        minValue = BigInt('-9223372036854775808');
-                        maxValue = BigInt('9223372036854775807');
-                    }
-                    else {
-                        // if (col.dataType === 'number')
-                        // if you’re expecting values above 2^31 but below 2^53
-                        minValue = -9007199254740991;
-                        maxValue = 9007199254740991;
-                    }
-                }
-            }
-            if (['smallint', 'integer', 'bigint'].includes(col.columnType)) {
-                const generator = new generatorsMap.GenerateInt[0]({
-                    minValue,
-                    maxValue,
-                });
-                return generator;
-            }
-            if (['smallserial', 'serial', 'bigserial'].includes(col.columnType)) {
-                const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-                generator.maxValue = maxValue;
-                return generator;
-            }
-            // NUMBER(real, double, decimal, numeric)
-            if (col.columnType === 'real'
-                || col.columnType === 'double precision'
-                || col.columnType.match(/^decimal(\(\d{1,6}(, ?-?\d{0,5})?\))?$/) !== null
-                || col.columnType.match(/^numeric(\(\d{1,6}(, ?-?\d{0,5})?\))?$/) !== null) {
-                if (col.typeParams.precision !== undefined) {
-                    const precision = col.typeParams.precision;
-                    const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
-                    const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
-                    const generator = new generatorsMap.GenerateNumber[0]({
-                        minValue: -maxAbsoluteValue,
-                        maxValue: maxAbsoluteValue,
-                        precision: Math.pow(10, scale),
-                    });
-                    return generator;
-                }
-                const generator = new generatorsMap.GenerateNumber[0]();
-                return generator;
-            }
-            // STRING
-            if ((col.columnType === 'text'
-                || col.columnType.match(/^varchar(\(\d+\))?$/) !== null
-                || col.columnType.match(/^char(\(\d+\))?$/) !== null)
-                && table.primaryKeys.includes(col.name)) {
-                const generator = new generatorsMap.GenerateUniqueString[0]();
-                return generator;
-            }
-            if ((col.columnType === 'text'
-                || col.columnType.match(/^varchar(\(\d+\))?$/) !== null
-                || col.columnType.match(/^char(\(\d+\))?$/) !== null)
-                && col.name.toLowerCase().includes('name')) {
-                const generator = new generatorsMap.GenerateFirstName[0]();
-                return generator;
-            }
-            if ((col.columnType === 'text'
-                || col.columnType.match(/^varchar(\(\d+\))?$/) !== null
-                || col.columnType.match(/^char(\(\d+\))?$/) !== null)
-                && col.name.toLowerCase().includes('email')) {
-                const generator = new generatorsMap.GenerateEmail[0]();
-                return generator;
-            }
-            if (col.columnType === 'text'
-                || col.columnType.match(/^varchar(\(\d+\))?$/) !== null
-                || col.columnType.match(/^char(\(\d+\))?$/) !== null) {
-                const generator = new generatorsMap.GenerateString[0]();
-                return generator;
-            }
-            // UUID
-            if (col.columnType === 'uuid') {
-                const generator = new generatorsMap.GenerateUUID[0]();
-                return generator;
-            }
-            // BOOLEAN
-            if (col.columnType === 'boolean') {
-                const generator = new generatorsMap.GenerateBoolean[0]();
-                return generator;
-            }
-            // DATE, TIME, TIMESTAMP
-            if (col.columnType === 'date') {
-                const generator = new generatorsMap.GenerateDate[0]();
-                return generator;
-            }
-            if (col.columnType.match(/^time((\(\d+\))|( with time zone))?$/) !== null) {
-                const generator = new generatorsMap.GenerateTime[0]();
-                return generator;
-            }
-            if (col.columnType.match(/^timestamp((\(\d+\))|( with time zone))?$/) !== null) {
-                const generator = new generatorsMap.GenerateTimestamp[0]();
-                return generator;
-            }
-            // JSON, JSONB
-            if (col.columnType === 'json' || col.columnType === 'jsonb') {
-                const generator = new generatorsMap.GenerateJson[0]();
-                return generator;
-            }
-            // if (col.columnType === "jsonb") {
-            //   const generator = new GenerateJsonb({});
-            //   return generator;
-            // }
-            // ENUM
-            if (col.enumValues !== undefined) {
-                const generator = new generatorsMap.GenerateEnum[0]({
-                    enumValues: col.enumValues,
-                });
-                return generator;
-            }
-            // INTERVAL
-            if (col.columnType.match(/^interval( .+)?$/) !== null) {
-                if (col.columnType === 'interval') {
-                    const generator = new generatorsMap.GenerateInterval[0]();
-                    return generator;
-                }
-                const fields = col.columnType.replace('interval ', '');
-                const generator = new generatorsMap.GenerateInterval[0]({ fields });
-                return generator;
-            }
-            // POINT, LINE
-            if (col.columnType === 'point') {
-                const generator = new generatorsMap.GeneratePoint[0]();
-                return generator;
-            }
-            if (col.columnType === 'line') {
-                const generator = new generatorsMap.GenerateLine[0]();
-                return generator;
-            }
-            if (col.hasDefault && col.default !== undefined) {
-                const generator = new generatorsMap.GenerateDefault[0]({
-                    defaultValue: col.default,
-                });
-                return generator;
-            }
-            return;
-        };
-        const generator = pickGenerator(table, col);
-        if (generator !== undefined) {
-            generator.isUnique = col.isUnique;
-            generator.dataType = col.dataType;
-            generator.stringLength = col.typeParams.length;
-        }
-        return generator;
-    };
-    selectGeneratorForMysqlColumn = (table, col) => {
-        const pickGenerator = (table, col) => {
-            // INT ------------------------------------------------------------------------------------------------------------
-            if ((col.columnType === 'serial'
-                || ['tinyint', 'smallint', 'mediumint', 'int', 'bigint'].includes(col.columnType))
-                && table.primaryKeys.includes(col.name)) {
-                const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-                return generator;
-            }
-            let minValue;
-            let maxValue;
-            if (col.columnType === 'serial') {
-                // 2^64 % 2 - 1, 8 bytes
-                minValue = BigInt(0);
-                maxValue = BigInt('9223372036854775807');
-            }
-            else if (['tinyint', 'smallint', 'mediumint', 'int', 'bigint'].includes(col.columnType)) {
-                if (col.columnType === 'tinyint') {
-                    // 2^8 / 2 - 1, 1 bytes
-                    minValue = -128;
-                    maxValue = 127;
-                }
-                else if (col.columnType === 'smallint') {
-                    // 2^16 / 2 - 1, 2 bytes
-                    minValue = -32768;
-                    maxValue = 32767;
-                }
-                else if (col.columnType === 'mediumint') {
-                    // 2^16 / 2 - 1, 2 bytes
-                    minValue = -8388608;
-                    maxValue = 8388607;
-                }
-                else if (col.columnType === 'int') {
-                    // 2^32 / 2 - 1, 4 bytes
-                    minValue = -2147483648;
-                    maxValue = 2147483647;
-                }
-                else if (col.columnType === 'bigint') {
-                    // 2^64 / 2 - 1, 8 bytes
-                    minValue = BigInt('-9223372036854775808');
-                    maxValue = BigInt('9223372036854775807');
-                }
-            }
-            if (['tinyint', 'smallint', 'mediumint', 'int', 'bigint'].includes(col.columnType)) {
-                const generator = new generatorsMap.GenerateInt[0]({
-                    minValue,
-                    maxValue,
-                });
-                return generator;
-            }
-            if (col.columnType === 'serial') {
-                const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-                generator.maxValue = maxValue;
-                return generator;
-            }
-            // NUMBER(real, double, decimal, float)
-            if (col.columnType === 'real'
-                || col.columnType === 'double'
-                || col.columnType === 'float'
-                || col.columnType.startsWith('decimal')
-                || col.columnType.startsWith('numeric')) {
-                if (col.typeParams.precision !== undefined) {
-                    const precision = col.typeParams.precision;
-                    const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
-                    const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
-                    const generator = new generatorsMap.GenerateNumber[0]({
-                        minValue: -maxAbsoluteValue,
-                        maxValue: maxAbsoluteValue,
-                        precision: Math.pow(10, scale),
-                    });
-                    return generator;
-                }
-                const generator = new generatorsMap.GenerateNumber[0]();
-                return generator;
-            }
-            // STRING
-            if ((col.columnType === 'text'
-                || col.columnType === 'blob'
-                || col.columnType.startsWith('char')
-                || col.columnType.startsWith('varchar')
-                || col.columnType.startsWith('binary')
-                || col.columnType.startsWith('varbinary'))
-                && table.primaryKeys.includes(col.name)) {
-                const generator = new generatorsMap.GenerateUniqueString[0]();
-                return generator;
-            }
-            if ((col.columnType === 'text'
-                || col.columnType === 'blob'
-                || col.columnType.startsWith('char')
-                || col.columnType.startsWith('varchar')
-                || col.columnType.startsWith('binary')
-                || col.columnType.startsWith('varbinary'))
-                && col.name.toLowerCase().includes('name')) {
-                const generator = new generatorsMap.GenerateFirstName[0]();
-                return generator;
-            }
-            if ((col.columnType === 'text'
-                || col.columnType === 'blob'
-                || col.columnType.startsWith('char')
-                || col.columnType.startsWith('varchar')
-                || col.columnType.startsWith('binary')
-                || col.columnType.startsWith('varbinary'))
-                && col.name.toLowerCase().includes('email')) {
-                const generator = new generatorsMap.GenerateEmail[0]();
-                return generator;
-            }
-            if (col.columnType === 'text'
-                || col.columnType === 'blob'
-                || col.columnType.startsWith('char')
-                || col.columnType.startsWith('varchar')
-                || col.columnType.startsWith('binary')
-                || col.columnType.startsWith('varbinary')) {
-                const generator = new generatorsMap.GenerateString[0]();
-                return generator;
-            }
-            // BOOLEAN
-            if (col.columnType === 'boolean') {
-                const generator = new generatorsMap.GenerateBoolean[0]();
-                return generator;
-            }
-            // DATE, TIME, TIMESTAMP, DATETIME, YEAR
-            if (col.columnType.startsWith('datetime')) {
-                const generator = new generatorsMap.GenerateDatetime[0]();
-                return generator;
-            }
-            if (col.columnType === 'date') {
-                const generator = new generatorsMap.GenerateDate[0]();
-                return generator;
-            }
-            if (col.columnType === 'time') {
-                const generator = new generatorsMap.GenerateTime[0]();
-                return generator;
-            }
-            if (col.columnType.startsWith('timestamp')) {
-                const generator = new generatorsMap.GenerateTimestamp[0]();
-                return generator;
-            }
-            if (col.columnType === 'year') {
-                const generator = new generatorsMap.GenerateYear[0]();
-                return generator;
-            }
-            // JSON
-            if (col.columnType === 'json') {
-                const generator = new generatorsMap.GenerateJson[0]();
-                return generator;
-            }
-            // ENUM
-            if (col.enumValues !== undefined) {
-                const generator = new generatorsMap.GenerateEnum[0]({
-                    enumValues: col.enumValues,
-                });
-                return generator;
-            }
-            if (col.hasDefault && col.default !== undefined) {
-                const generator = new generatorsMap.GenerateDefault[0]({
-                    defaultValue: col.default,
-                });
-                return generator;
-            }
-            return;
-        };
-        const generator = pickGenerator(table, col);
-        return generator;
-    };
-    selectGeneratorForSqlite = (table, col) => {
-        const pickGenerator = (table, col) => {
-            // int section ---------------------------------------------------------------------------------------
-            if ((col.columnType === 'integer' || col.columnType === 'numeric')
-                && table.primaryKeys.includes(col.name)) {
-                const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-                return generator;
-            }
-            if (col.columnType === 'integer' && col.dataType === 'boolean') {
-                const generator = new generatorsMap.GenerateBoolean[0]();
-                return generator;
-            }
-            if ((col.columnType === 'integer' && col.dataType === 'date')) {
-                const generator = new generatorsMap.GenerateTimestamp[0]();
-                return generator;
-            }
-            if (col.columnType === 'integer'
-                || (col.dataType === 'bigint' && col.columnType === 'blob')) {
-                const generator = new generatorsMap.GenerateInt[0]();
-                return generator;
-            }
-            // number section ------------------------------------------------------------------------------------
-            if (col.columnType.startsWith('real')
-                || col.columnType.startsWith('numeric')) {
-                if (col.typeParams.precision !== undefined) {
-                    const precision = col.typeParams.precision;
-                    const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
-                    const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
-                    const generator = new generatorsMap.GenerateNumber[0]({
-                        minValue: -maxAbsoluteValue,
-                        maxValue: maxAbsoluteValue,
-                        precision: Math.pow(10, scale),
-                    });
-                    return generator;
-                }
-                const generator = new generatorsMap.GenerateNumber[0]();
-                return generator;
-            }
-            // string section ------------------------------------------------------------------------------------
-            if ((col.columnType.startsWith('text')
-                || col.columnType.startsWith('numeric')
-                || col.columnType.startsWith('blob'))
-                && table.primaryKeys.includes(col.name)) {
-                const generator = new generatorsMap.GenerateUniqueString[0]();
-                return generator;
-            }
-            if ((col.columnType.startsWith('text')
-                || col.columnType.startsWith('numeric')
-                || col.columnType.startsWith('blob'))
-                && col.name.toLowerCase().includes('name')) {
-                const generator = new generatorsMap.GenerateFirstName[0]();
-                return generator;
-            }
-            if ((col.columnType.startsWith('text')
-                || col.columnType.startsWith('numeric')
-                || col.columnType.startsWith('blob'))
-                && col.name.toLowerCase().includes('email')) {
-                const generator = new generatorsMap.GenerateEmail[0]();
-                return generator;
-            }
-            if (col.columnType.startsWith('text')
-                || col.columnType.startsWith('numeric')
-                || col.columnType.startsWith('blob')
-                || col.columnType.startsWith('blobbuffer')) {
-                const generator = new generatorsMap.GenerateString[0]();
-                return generator;
-            }
-            if ((col.columnType.startsWith('text') && col.dataType === 'json')
-                || (col.columnType.startsWith('blob') && col.dataType === 'json')) {
-                const generator = new generatorsMap.GenerateJson[0]();
-                return generator;
-            }
-            if (col.hasDefault && col.default !== undefined) {
-                const generator = new generatorsMap.GenerateDefault[0]({
-                    defaultValue: col.default,
-                });
-                return generator;
-            }
-            return;
-        };
-        const generator = pickGenerator(table, col);
-        return generator;
-    };
     filterCyclicTables = (tablesGenerators) => {
         const filteredTablesGenerators = tablesGenerators.filter((tableGen) => tableGen.columnsPossibleGenerators.some((columnGen) => columnGen.isCyclic === true && columnGen.wasDefinedBefore === true));
         const tablesUniqueNotNullColumn = {};
@@ -135176,7 +136403,8 @@ class SeedService {
                 throw new Error(`Table '${tableGen.tableName}' does not have primary or (unique and notNull) column. Can't seed table with cyclic relation.`);
             }
             tablesUniqueNotNullColumn[tableGen.tableName] = { uniqueNotNullColName };
-            filteredTablesGenerators[idx].columnsPossibleGenerators = tableGen.columnsPossibleGenerators.filter((colGen) => (colGen.isCyclic === true && colGen.wasDefinedBefore === true) || colGen.columnName === uniqueNotNullColName).map((colGen) => {
+            filteredTablesGenerators[idx].columnsPossibleGenerators = tableGen.columnsPossibleGenerators.filter((colGen) => (colGen.isCyclic === true && colGen.wasDefinedBefore === true) || colGen.columnName === uniqueNotNullColName)
+                .map((colGen) => {
                 const newColGen = { ...colGen };
                 newColGen.wasDefinedBefore = false;
                 return newColGen;
@@ -135270,7 +136498,9 @@ class SeedService {
                                 weightedCountSeed = table.withFromTable[rel.refTable].weightedCountSeed;
                             }
                             // TODO: revise maybe need to select version of generator here too
-                            genObj = new generatorsMap.GenerateValuesFromArray[0]({ values: refColumnValues });
+                            genObj = new generatorsMap.GenerateValuesFromArray[0]({
+                                values: refColumnValues,
+                            });
                             genObj.notNull = tableGenerators[rel.columns[colIdx]].notNull;
                             genObj.weightedCountSeed = weightedCountSeed;
                             genObj.maxRepeatedValuesCount = repeatedValuesCount;
@@ -135338,7 +136568,10 @@ class SeedService {
         for (const columnName of Object.keys(tableGenerators)) {
             columnsNumber += 1;
             columnGenerator = tableGenerators[columnName];
+            // postgres identity columns
             override = tableGenerators[columnName]?.generatedIdentityType === 'always' ? true : override;
+            // mssql identity columns
+            override = tableGenerators[columnName]?.identity === true ? true : override;
             columnsGenerators[columnName] = columnGenerator.generator;
             columnsGenerators[columnName].init({
                 count,
@@ -135363,10 +136596,13 @@ class SeedService {
         else if (is(db, (MySqlDatabase))) {
             maxParametersNumber = this.mysqlMaxParametersNumber;
         }
-        else {
-            // is(db, BaseSQLiteDatabase<any, any>)
+        else if (is(db, (BaseSQLiteDatabase))) {
             maxParametersNumber = this.sqliteMaxParametersNumber;
         }
+        else {
+            // is(db, MsSqlDatabase<any, any>)
+            maxParametersNumber = this.mssqlMaxParametersNumber;
+        }
         const maxBatchSize = Math.floor(maxParametersNumber / columnsNumber);
         batchSize = batchSize > maxBatchSize ? maxBatchSize : batchSize;
         if ((insertDataInDb === true || updateDataInDb === true)
@@ -135451,24 +136687,640 @@ class SeedService {
                 .insert(schema[tableName])
                 .values(generatedValues);
         }
+        else if (is(db, (MsSqlDatabase))) {
+            let schemaDbName;
+            let tableDbName;
+            if (override === true) {
+                const tableConfig = getTableConfig$5(schema[tableName]);
+                schemaDbName = tableConfig.schema ?? 'dbo';
+                tableDbName = tableConfig.name;
+                await db.execute(sql.raw(`SET IDENTITY_INSERT [${schemaDbName}].[${tableDbName}] ON;`));
+            }
+            await db
+                .insert(schema[tableName])
+                .values(generatedValues);
+            if (override === true) {
+                await db.execute(sql.raw(`SET IDENTITY_INSERT [${schemaDbName}].[${tableDbName}] OFF;`));
+            }
+        }
+        else if (is(db, (CockroachDatabase))) {
+            const query = db
+                .insert(schema[tableName])
+                .values(generatedValues);
+            await query;
+        }
+        else if (is(db, (SingleStoreDatabase))) {
+            const query = db
+                .insert(schema[tableName])
+                .values(generatedValues);
+            await query;
+        }
     };
     updateDb = async ({ generatedValues, db, schema, tableName, uniqueNotNullColName, }) => {
+        let values = generatedValues[0];
+        const uniqueNotNullColValue = values[uniqueNotNullColName];
+        values = Object.fromEntries(Object.entries(values).filter(([colName]) => colName !== uniqueNotNullColName));
         if (is(db, (PgDatabase))) {
             const table = schema[tableName];
             const uniqueNotNullCol = table[uniqueNotNullColName];
-            await db.update(table).set(generatedValues[0]).where(eq(uniqueNotNullCol, generatedValues[0][uniqueNotNullColName]));
+            await db.update(table).set(values).where(eq(uniqueNotNullCol, uniqueNotNullColValue));
         }
         else if (is(db, (MySqlDatabase))) {
             const table = schema[tableName];
-            await db.update(table).set(generatedValues[0]).where(eq(table[uniqueNotNullColName], generatedValues[0][uniqueNotNullColName]));
+            await db.update(table).set(values).where(eq(table[uniqueNotNullColName], uniqueNotNullColValue));
         }
         else if (is(db, (BaseSQLiteDatabase))) {
             const table = schema[tableName];
-            await db.update(table).set(generatedValues[0]).where(eq(table[uniqueNotNullColName], generatedValues[0][uniqueNotNullColName]));
+            await db.update(table).set(values).where(eq(table[uniqueNotNullColName], uniqueNotNullColValue));
+        }
+        else if (is(db, (MsSqlDatabase))) {
+            const table = schema[tableName];
+            await db.update(table).set(values).where(eq(table[uniqueNotNullColName], uniqueNotNullColValue));
+        }
+        else if (is(db, (CockroachDatabase))) {
+            const table = schema[tableName];
+            await db.update(table).set(values).where(eq(table[uniqueNotNullColName], uniqueNotNullColValue));
+        }
+        else if (is(db, (SingleStoreDatabase))) {
+            const table = schema[tableName];
+            await db.update(table).set(values).where(eq(table[uniqueNotNullColName], uniqueNotNullColValue));
         }
     };
 }
 
+// Cockroach-----------------------------------------------------------------------------------------------------------
+const resetCockroach = async (db, cockroachTables) => {
+    const tablesToTruncate = Object.entries(cockroachTables).map(([_, table]) => {
+        const config = getTableConfig$4(table);
+        config.schema = config.schema === undefined ? 'public' : config.schema;
+        return `"${config.schema}"."${config.name}"`;
+    });
+    await db.execute(sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
+};
+const filterCockroachSchema = (schema) => {
+    const cockroachSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], CockroachTable) || is(keyValue[1], Relations)));
+    const cockroachTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], CockroachTable)));
+    return { cockroachSchema, cockroachTables };
+};
+const seedCockroach = async (db, schema, options = {}, refinements) => {
+    const seedService = new SeedService();
+    const { cockroachSchema, cockroachTables } = filterCockroachSchema(schema);
+    const { tables, relations } = getSchemaInfo(cockroachSchema, cockroachTables, mapCockroachTable);
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('cockroach', tables, relations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, cockroachTables, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, cockroachTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+};
+const mapCockroachTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getAllBaseColumns = (baseColumn) => {
+        const baseColumnResult = {
+            name: baseColumn.name,
+            columnType: baseColumn.getSQLType(),
+            typeParams: getTypeParams(baseColumn.getSQLType()),
+            dataType: baseColumn.dataType.split(' ')[0],
+            size: baseColumn.length,
+            hasDefault: baseColumn.hasDefault,
+            enumValues: baseColumn.enumValues,
+            default: baseColumn.default,
+            isUnique: baseColumn.isUnique,
+            notNull: baseColumn.notNull,
+            primary: baseColumn.primary,
+            baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
+        };
+        return baseColumnResult;
+    };
+    const getTypeParams = (sqlType) => {
+        // get type params
+        const typeParams = {};
+        // handle dimensions
+        if (sqlType.includes('[')) {
+            const match = sqlType.match(/\[\w*]/g);
+            if (match) {
+                typeParams['dimensions'] = match.length;
+            }
+        }
+        if (sqlType.startsWith('numeric')
+            || sqlType.startsWith('decimal')
+            || sqlType.startsWith('double precision')
+            || sqlType.startsWith('real')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
+            }
+        }
+        else if (sqlType.startsWith('varchar')
+            || sqlType.startsWith('char')
+            || sqlType.startsWith('bit')
+            || sqlType.startsWith('vector')
+            || sqlType.startsWith('time')
+            || sqlType.startsWith('timestamp')
+            || sqlType.startsWith('interval')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
+            }
+        }
+        return typeParams;
+    };
+    // console.log(tableConfig.columns);
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            size: column.length,
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+            generatedIdentityType: column.generatedIdentity?.type,
+            baseColumn: (column.baseColumn === undefined)
+                ? undefined
+                : getAllBaseColumns(column.baseColumn),
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
+};
+
+// MySql-----------------------------------------------------------------------------------------------------
+const resetMsSql = async (db, schema) => {
+    const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+        const tableConfig = getTableConfig$5(table);
+        return { dbName: tableConfig.name, dbSchema: tableConfig.schema ?? 'dbo' };
+    });
+    const allFkConstraints = {};
+    for (const table of tablesToTruncate) {
+        const gatherTableRelatedFkConstraints = `
+			DECLARE @objectId INT
+  			= OBJECT_ID( QUOTENAME('${table.dbSchema}') + '.' + QUOTENAME('${table.dbName}') );
+
+			SELECT
+			    fk.name                             AS fkName,
+			    OBJECT_SCHEMA_NAME(fk.parent_object_id)   AS parentSchema,
+			    OBJECT_NAME(fk.parent_object_id)         AS parentTable,
+			    OBJECT_SCHEMA_NAME(fk.referenced_object_id) AS referencedSchema,
+			    OBJECT_NAME(fk.referenced_object_id)       AS referencedTable,
+			--     fkc.constraint_column_id       AS Column_Ordinal,
+			    pc.name                        AS parentColumn,
+			    rc.name                        AS referencedColumn,
+			    fk.delete_referential_action_desc AS onDeleteAction,
+			    fk.update_referential_action_desc AS onUpdateAction,
+			    CASE
+			        WHEN fk.parent_object_id     = @objectId THEN 'outbound'  -- your table → another table
+			        ELSE 'inbound'                                           -- another table → your table
+			    END                                 AS relation
+			FROM sys.foreign_keys AS fk
+			JOIN sys.foreign_key_columns fkc
+			  ON fk.object_id = fkc.constraint_object_id
+			JOIN sys.columns             pc
+			  ON fkc.parent_object_id   = pc.object_id
+			 AND fkc.parent_column_id   = pc.column_id
+			JOIN sys.columns             rc
+			  ON fkc.referenced_object_id = rc.object_id
+			 AND fkc.referenced_column_id = rc.column_id
+			WHERE fk.parent_object_id     = @objectId
+			   OR fk.referenced_object_id = @objectId
+			ORDER BY relation, fkName;
+		`;
+        const rawRes = await db.execute(sql.raw(gatherTableRelatedFkConstraints));
+        const res = rawRes.recordset;
+        const tableRelatedFkConstraints = {};
+        for (const fkInfo of res) {
+            if (tableRelatedFkConstraints[fkInfo.fkName] === undefined) {
+                const { parentColumn: _, referencedColumn: __, ...filteredFkInfo } = fkInfo;
+                tableRelatedFkConstraints[fkInfo.fkName] = {
+                    ...filteredFkInfo,
+                    parentColumns: res.filter(({ fkName }) => fkName === fkInfo.fkName).map(({ parentColumn }) => parentColumn),
+                    referencedColumns: res.filter(({ fkName }) => fkName === fkInfo.fkName).map(({ referencedColumn }) => referencedColumn),
+                };
+            }
+        }
+        allFkConstraints[`${table.dbSchema}.${table.dbName}`] = tableRelatedFkConstraints;
+        // drop all table related fk constraints
+        for (const fkInfo of Object.values(tableRelatedFkConstraints)) {
+            const dropFkConstraints = `ALTER TABLE [${fkInfo.parentSchema}].[${fkInfo.parentTable}] DROP CONSTRAINT [${fkInfo.fkName}];`;
+            await db.execute(sql.raw(dropFkConstraints));
+        }
+        // truncating
+        const truncateTable = `truncate table [${table.dbSchema}].[${table.dbName}];`;
+        await db.execute(sql.raw(truncateTable));
+    }
+    // add all table related fk constraints
+    for (const table of tablesToTruncate) {
+        const tableRelatedFkConstraints = allFkConstraints[`${table.dbSchema}.${table.dbName}`];
+        for (const fkInfo of Object.values(tableRelatedFkConstraints)) {
+            const addFkConstraints = `
+				ALTER TABLE [${fkInfo.parentSchema}].[${fkInfo.parentTable}] 
+				ADD CONSTRAINT [${fkInfo.fkName}] 
+				FOREIGN KEY(${fkInfo.parentColumns.map((colName) => `[${colName}]`).join(',')})
+				REFERENCES [${fkInfo.referencedSchema}].[${fkInfo.referencedTable}] (${fkInfo.referencedColumns.map((colName) => `[${colName}]`).join(',')})
+				ON DELETE ${fkInfo.onDeleteAction.split('_').join(' ')}
+				ON UPDATE ${fkInfo.onUpdateAction.split('_').join(' ')};
+				`;
+            await db.execute(sql.raw(addFkConstraints));
+        }
+    }
+};
+const filterMsSqlTables = (schema) => {
+    const mssqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], MsSqlTable) || is(keyValue[1], Relations)));
+    const mssqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], MsSqlTable)));
+    return { mssqlSchema, mssqlTables };
+};
+const seedMsSql = async (db, schema, options = {}, refinements) => {
+    const { mssqlSchema, mssqlTables } = filterMsSqlTables(schema);
+    const { tables, relations } = getSchemaInfo(mssqlSchema, mssqlTables, mapMsSqlTable);
+    const seedService = new SeedService();
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('mssql', tables, relations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, mssqlTables, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, mssqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+};
+const mapMsSqlTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    // TODO: rewrite
+    const getTypeParams = (sqlType) => {
+        // get type params and set only type
+        const typeParams = {};
+        if (sqlType.startsWith('decimal')
+            || sqlType.startsWith('real')
+            || sqlType.startsWith('float')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
+            }
+        }
+        else if (sqlType.startsWith('char')
+            || sqlType.startsWith('varchar')
+            || sqlType.startsWith('binary')
+            || sqlType.startsWith('varbinary')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
+            }
+        }
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+            identity: column.identity ? true : false,
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
+};
+
+// MySql-----------------------------------------------------------------------------------------------------
+const resetMySql = async (db, schema) => {
+    const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+        const dbTableName = getTableName(table);
+        return dbTableName;
+    });
+    await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 0;'));
+    for (const tableName of tablesToTruncate) {
+        const sqlQuery = `truncate \`${tableName}\`;`;
+        await db.execute(sql.raw(sqlQuery));
+    }
+    await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
+};
+const filterMysqlTables = (schema) => {
+    const mysqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], MySqlTable) || is(keyValue[1], Relations)));
+    const mysqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], MySqlTable)));
+    return { mysqlSchema, mysqlTables };
+};
+const seedMySql = async (db, schema, options = {}, refinements) => {
+    const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
+    const { tables, relations } = getSchemaInfo(mysqlSchema, mysqlTables, mapMySqlTable);
+    const seedService = new SeedService();
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, mysqlTables, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, mysqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+};
+const mapMySqlTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getTypeParams = (sqlType) => {
+        // get type params and set only type
+        const typeParams = {};
+        if (sqlType.startsWith('decimal')
+            || sqlType.startsWith('real')
+            || sqlType.startsWith('double')
+            || sqlType.startsWith('float')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
+            }
+        }
+        else if (sqlType.startsWith('char')
+            || sqlType.startsWith('varchar')
+            || sqlType.startsWith('binary')
+            || sqlType.startsWith('varbinary')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
+            }
+        }
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
+};
+
+// Postgres-----------------------------------------------------------------------------------------------------------
+const resetPostgres = async (db, pgTables) => {
+    const tablesToTruncate = Object.entries(pgTables).map(([_, table]) => {
+        const config = getTableConfig$1(table);
+        config.schema = config.schema === undefined ? 'public' : config.schema;
+        return `"${config.schema}"."${config.name}"`;
+    });
+    await db.execute(sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
+};
+const filterPgSchema = (schema) => {
+    const pgSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], PgTable) || is(keyValue[1], Relations)));
+    const pgTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], PgTable)));
+    return { pgSchema, pgTables };
+};
+const seedPostgres = async (db, schema, options = {}, refinements) => {
+    const seedService = new SeedService();
+    const { pgSchema, pgTables } = filterPgSchema(schema);
+    const { tables, relations } = getSchemaInfo(pgSchema, pgTables, mapPgTable);
+    // const { tables, relations } = getPostgresInfo(pgSchema, pgTables);
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('postgresql', tables, relations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, pgTables, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, pgTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+};
+const mapPgTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getAllBaseColumns = (baseColumn) => {
+        const baseColumnResult = {
+            name: baseColumn.name,
+            columnType: baseColumn.getSQLType(),
+            typeParams: getTypeParams(baseColumn.getSQLType()),
+            dataType: baseColumn.dataType.split(' ')[0],
+            size: baseColumn.length,
+            hasDefault: baseColumn.hasDefault,
+            enumValues: baseColumn.enumValues,
+            default: baseColumn.default,
+            isUnique: baseColumn.isUnique,
+            notNull: baseColumn.notNull,
+            primary: baseColumn.primary,
+            baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
+        };
+        return baseColumnResult;
+    };
+    const getTypeParams = (sqlType) => {
+        // get type params
+        const typeParams = {};
+        // handle dimensions
+        if (sqlType.includes('[')) {
+            const match = sqlType.match(/\[\w*]/g);
+            if (match) {
+                typeParams['dimensions'] = match.length;
+            }
+        }
+        if (sqlType.startsWith('numeric')
+            || sqlType.startsWith('decimal')
+            || sqlType.startsWith('double precision')
+            || sqlType.startsWith('real')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
+            }
+        }
+        else if (sqlType.startsWith('varchar')
+            || sqlType.startsWith('bpchar')
+            || sqlType.startsWith('char')
+            || sqlType.startsWith('bit')
+            || sqlType.startsWith('vector')
+            || sqlType.startsWith('time')
+            || sqlType.startsWith('timestamp')
+            || sqlType.startsWith('interval')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
+            }
+        }
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            size: column.length,
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+            generatedIdentityType: column.generatedIdentity?.type,
+            baseColumn: (column.baseColumn === undefined)
+                ? undefined
+                : getAllBaseColumns(column.baseColumn),
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
+};
+
+// SingleStore-----------------------------------------------------------------------------------------------------
+const resetSingleStore = async (db, schema) => {
+    const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+        const dbTableName = getTableName(table);
+        return dbTableName;
+    });
+    await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 0;'));
+    for (const tableName of tablesToTruncate) {
+        const sqlQuery = `truncate \`${tableName}\`;`;
+        await db.execute(sql.raw(sqlQuery));
+    }
+    await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
+};
+const filterSingleStoreTables = (schema) => {
+    const singleStoreSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], SingleStoreTable) || is(keyValue[1], Relations)));
+    const singleStoreTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], SingleStoreTable)));
+    return { singleStoreSchema, singleStoreTables };
+};
+const seedSingleStore = async (db, schema, options = {}, refinements) => {
+    const { singleStoreSchema, singleStoreTables } = filterSingleStoreTables(schema);
+    const { tables, relations } = getSchemaInfo(singleStoreSchema, singleStoreTables, mapSingleStoreTable);
+    const seedService = new SeedService();
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('singlestore', tables, relations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, singleStoreTables, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, singleStoreTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+};
+const mapSingleStoreTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getTypeParams = (sqlType) => {
+        // get type params and set only type
+        const typeParams = {};
+        if (sqlType.startsWith('decimal')
+            || sqlType.startsWith('real')
+            || sqlType.startsWith('double')
+            || sqlType.startsWith('float')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
+            }
+        }
+        else if (sqlType.startsWith('char')
+            || sqlType.startsWith('varchar')
+            || sqlType.startsWith('binary')
+            || sqlType.startsWith('varbinary')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
+            }
+        }
+        else if (sqlType.startsWith('vector')) {
+            const match = sqlType.match(/\((\d+),? ?((F|I)\d{1,2})?\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
+                typeParams['vectorValueType'] = match[2];
+            }
+        }
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
+};
+
+// Sqlite------------------------------------------------------------------------------------------------------------------------
+const resetSqlite = async (db, schema) => {
+    const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+        const dbTableName = getTableName(table);
+        return dbTableName;
+    });
+    await db.run(sql.raw('PRAGMA foreign_keys = OFF'));
+    for (const tableName of tablesToTruncate) {
+        const sqlQuery = `delete from \`${tableName}\`;`;
+        await db.run(sql.raw(sqlQuery));
+    }
+    await db.run(sql.raw('PRAGMA foreign_keys = ON'));
+};
+const filterSqliteTables = (schema) => {
+    const sqliteSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], SQLiteTable) || is(keyValue[1], Relations)));
+    const sqliteTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], SQLiteTable)));
+    return { sqliteSchema, sqliteTables };
+};
+const seedSqlite = async (db, schema, options = {}, refinements) => {
+    const { sqliteSchema, sqliteTables } = filterSqliteTables(schema);
+    const { tables, relations } = getSchemaInfo(sqliteSchema, sqliteTables, mapSqliteTable);
+    const seedService = new SeedService();
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('sqlite', tables, relations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, sqliteTables, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, sqliteTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+};
+const mapSqliteTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getTypeParams = (sqlType) => {
+        // get type params and set only type
+        const typeParams = {};
+        if (sqlType.startsWith('decimal')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
+            }
+        }
+        else if (sqlType.startsWith('char')
+            || sqlType.startsWith('varchar')
+            || sqlType.startsWith('text')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
+            }
+        }
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
+};
+
 /* eslint-disable drizzle-internal/require-entity-kind */
 class SeedPromise {
     db;
@@ -135571,7 +137423,7 @@ async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleSt
  * // seeding with count and seed specified
  * await seed(db, schema, { count: 100000, seed: 1 });
  *
- * // seeding using refine
+ * //seeding using refine
  * await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  *   users: {
  *     columns: {
@@ -135592,17 +137444,6 @@ async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleSt
  *   },
  * }));
  *
- * // seeding while ignoring column
- * await seed(db, schema).refine((funcs) => ({
- *   users: {
- *     count: 5,
- *     columns: {
- *       name: funcs.fullName(),
- *       photo: false, // the photo column will not be seeded, allowing the database to use its default value.
- *     },
- *   },
- * }));
- *
  * ```
  */
 function seed(db, schema, options) {
@@ -135622,8 +137463,17 @@ const seedFunc = async (db, schema, options = {}, refinements) => {
     else if (is(db, (BaseSQLiteDatabase))) {
         await seedSqlite(db, schema, { ...options, version }, refinements);
     }
+    else if (is(db, (MsSqlDatabase))) {
+        await seedMsSql(db, schema, { ...options, version }, refinements);
+    }
+    else if (is(db, (CockroachDatabase))) {
+        await seedCockroach(db, schema, { ...options, version }, refinements);
+    }
+    else if (is(db, (SingleStoreDatabase))) {
+        await seedSingleStore(db, schema, { ...options, version }, refinements);
+    }
     else {
-        throw new Error('The drizzle-seed package currently supports only PostgreSQL, MySQL, and SQLite databases. Please ensure your database is one of these supported types');
+        throw new Error('The drizzle-seed package currently supports only PostgreSQL, MySQL, SQLite, Ms Sql, CockroachDB and SingleStore databases. Please ensure your database is one of these supported types');
     }
     return;
 };
@@ -135665,10 +137515,6 @@ const seedFunc = async (db, schema, options = {}, refinements) => {
  * @example
  * ```ts
  * await reset(db, schema);
- *
- * // Alternatively, you can provide an object containing your tables
- * // as the `schema` parameter when calling `reset`.
- * await reset(db, { users });
  * ```
  */
 async function reset(db, schema) {
@@ -135690,623 +137536,28 @@ async function reset(db, schema) {
             await resetSqlite(db, sqliteTables);
         }
     }
-    else {
-        throw new Error('The drizzle-seed package currently supports only PostgreSQL, MySQL, and SQLite databases. Please ensure your database is one of these supported types');
-    }
-}
-// Postgres-----------------------------------------------------------------------------------------------------------
-const resetPostgres = async (db, pgTables) => {
-    const tablesToTruncate = Object.entries(pgTables).map(([_, table]) => {
-        const config = getTableConfig(table);
-        config.schema = config.schema === undefined ? 'public' : config.schema;
-        return `"${config.schema}"."${config.name}"`;
-    });
-    await db.execute(sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
-};
-const filterPgSchema = (schema) => {
-    const pgSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], PgTable) || is(keyValue[1], Relations)));
-    const pgTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], PgTable)));
-    return { pgSchema, pgTables };
-};
-const seedPostgres = async (db, schema, options = {}, refinements) => {
-    const seedService = new SeedService();
-    const { pgSchema, pgTables } = filterPgSchema(schema);
-    const { tables, relations } = getPostgresInfo(pgSchema, pgTables);
-    const generatedTablesGenerators = seedService.generatePossibleGenerators('postgresql', tables, relations, refinements, options);
-    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, pgTables, { ...options, preserveCyclicTablesData });
-    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
-    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, pgTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
-};
-const getPostgresInfo = (pgSchema, pgTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(pgTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
-    };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig(drizzleRel.sourceTable);
-                const tableDbSchema = tableConfig.schema ?? 'public';
-                const tableDbName = tableConfig.name;
-                const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig(drizzleRel.referencedTable);
-                const refTableDbSchema = refTableConfig.schema ?? 'public';
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
-            }
-        }
-        return relations;
-    };
-    for (const table of Object.values(pgTables)) {
-        tableConfig = getTableConfig(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        // might be empty list
-        const newRelations = tableConfig.foreignKeys.map((fk) => {
-            const table = dbToTsTableNamesMap[tableConfig.name];
-            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
-            }
-            return {
-                table,
-                columns: fk
-                    .reference()
-                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
-                refTable,
-                refColumns: fk
-                    .reference()
-                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
-                refTableRels: tableRelations[refTable],
-            };
-        });
-        relations.push(...newRelations);
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
-        }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        const getAllBaseColumns = (baseColumn) => {
-            const baseColumnResult = {
-                name: baseColumn.name,
-                columnType: baseColumn.getSQLType(),
-                typeParams: getTypeParams(baseColumn.getSQLType()),
-                dataType: baseColumn.dataType,
-                size: baseColumn.size,
-                hasDefault: baseColumn.hasDefault,
-                enumValues: baseColumn.enumValues,
-                default: baseColumn.default,
-                isUnique: baseColumn.isUnique,
-                notNull: baseColumn.notNull,
-                primary: baseColumn.primary,
-                baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
-            };
-            return baseColumnResult;
-        };
-        const getTypeParams = (sqlType) => {
-            // get type params
-            const typeParams = {};
-            // handle dimensions
-            if (sqlType.includes('[')) {
-                const match = sqlType.match(/\[\w*]/g);
-                if (match) {
-                    typeParams['dimensions'] = match.length;
-                }
-            }
-            if (sqlType.startsWith('numeric')
-                || sqlType.startsWith('decimal')
-                || sqlType.startsWith('double precision')
-                || sqlType.startsWith('real')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
-            }
-            else if (sqlType.startsWith('varchar')
-                || sqlType.startsWith('bpchar')
-                || sqlType.startsWith('char')
-                || sqlType.startsWith('bit')
-                || sqlType.startsWith('time')
-                || sqlType.startsWith('timestamp')
-                || sqlType.startsWith('interval')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
-            }
-            return typeParams;
-        };
-        // console.log(tableConfig.columns);
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                size: column.size,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-                generatedIdentityType: column.generatedIdentity?.type,
-                baseColumn: (column.baseColumn === undefined)
-                    ? undefined
-                    : getAllBaseColumns(column.baseColumn),
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
-    }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(pgSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const isCyclicRelations = relations.map((relI) => {
-        // if (relations.some((relj) => relI.table === relj.refTable && relI.refTable === relj.table)) {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
-        }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: isCyclicRelations, tableRelations };
-};
-const isRelationCyclic = (startRel) => {
-    // self relation
-    if (startRel.table === startRel.refTable)
-        return false;
-    // DFS
-    const targetTable = startRel.table;
-    const queue = [startRel];
-    let path = [];
-    while (queue.length !== 0) {
-        const currRel = queue.shift();
-        if (path.includes(currRel.table)) {
-            const idx = path.indexOf(currRel.table);
-            path = path.slice(0, idx);
-        }
-        path.push(currRel.table);
-        for (const rel of currRel.refTableRels) {
-            // self relation
-            if (rel.table === rel.refTable)
-                continue;
-            if (rel.refTable === targetTable)
-                return true;
-            // found cycle, but not the one we are looking for
-            if (path.includes(rel.refTable))
-                continue;
-            queue.unshift(rel);
+    else if (is(db, (MsSqlDatabase))) {
+        const { mssqlTables } = filterMsSqlTables(schema);
+        if (Object.entries(mssqlTables).length > 0) {
+            await resetMsSql(db, mssqlTables);
         }
     }
-    return false;
-};
-// MySql-----------------------------------------------------------------------------------------------------
-const resetMySql = async (db, schema) => {
-    const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
-        const dbTableName = getTableName(table);
-        return dbTableName;
-    });
-    await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 0;'));
-    for (const tableName of tablesToTruncate) {
-        const sqlQuery = `truncate \`${tableName}\`;`;
-        await db.execute(sql.raw(sqlQuery));
-    }
-    await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
-};
-const filterMysqlTables = (schema) => {
-    const mysqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], MySqlTable) || is(keyValue[1], Relations)));
-    const mysqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], MySqlTable)));
-    return { mysqlSchema, mysqlTables };
-};
-const seedMySql = async (db, schema, options = {}, refinements) => {
-    const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
-    const { tables, relations } = getMySqlInfo(mysqlSchema, mysqlTables);
-    const seedService = new SeedService();
-    const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, refinements, options);
-    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, mysqlTables, { ...options, preserveCyclicTablesData });
-    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
-    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, mysqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
-};
-const getMySqlInfo = (mysqlSchema, mysqlTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(mysqlTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig$1(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
-    };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig$1(drizzleRel.sourceTable);
-                const tableDbSchema = tableConfig.schema ?? 'public';
-                const tableDbName = tableConfig.name;
-                const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig$1(drizzleRel.referencedTable);
-                const refTableDbSchema = refTableConfig.schema ?? 'public';
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
-            }
-        }
-        return relations;
-    };
-    for (const table of Object.values(mysqlTables)) {
-        tableConfig = getTableConfig$1(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        const newRelations = tableConfig.foreignKeys.map((fk) => {
-            const table = dbToTsTableNamesMap[tableConfig.name];
-            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
-            }
-            return {
-                table,
-                columns: fk
-                    .reference()
-                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
-                refTable,
-                refColumns: fk
-                    .reference()
-                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
-                refTableRels: tableRelations[refTable],
-            };
-        });
-        relations.push(...newRelations);
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
+    else if (is(db, (CockroachDatabase))) {
+        const { cockroachTables } = filterCockroachSchema(schema);
+        if (Object.entries(cockroachTables).length > 0) {
+            await resetCockroach(db, cockroachTables);
         }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        const getTypeParams = (sqlType) => {
-            // get type params and set only type
-            const typeParams = {};
-            if (sqlType.startsWith('decimal')
-                || sqlType.startsWith('real')
-                || sqlType.startsWith('double')
-                || sqlType.startsWith('float')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
-            }
-            else if (sqlType.startsWith('char')
-                || sqlType.startsWith('varchar')
-                || sqlType.startsWith('binary')
-                || sqlType.startsWith('varbinary')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
-            }
-            return typeParams;
-        };
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
     }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(mysqlSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const isCyclicRelations = relations.map((relI) => {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
+    else if (is(db, (SingleStoreDatabase))) {
+        const { singleStoreTables } = filterSingleStoreTables(schema);
+        if (Object.entries(singleStoreTables).length > 0) {
+            await resetSingleStore(db, singleStoreTables);
         }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: isCyclicRelations, tableRelations };
-};
-// Sqlite------------------------------------------------------------------------------------------------------------------------
-const resetSqlite = async (db, schema) => {
-    const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
-        const dbTableName = getTableName(table);
-        return dbTableName;
-    });
-    await db.run(sql.raw('PRAGMA foreign_keys = OFF'));
-    for (const tableName of tablesToTruncate) {
-        const sqlQuery = `delete from \`${tableName}\`;`;
-        await db.run(sql.raw(sqlQuery));
     }
-    await db.run(sql.raw('PRAGMA foreign_keys = ON'));
-};
-const filterSqliteTables = (schema) => {
-    const sqliteSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], SQLiteTable) || is(keyValue[1], Relations)));
-    const sqliteTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => is(keyValue[1], SQLiteTable)));
-    return { sqliteSchema, sqliteTables };
-};
-const seedSqlite = async (db, schema, options = {}, refinements) => {
-    const { sqliteSchema, sqliteTables } = filterSqliteTables(schema);
-    const { tables, relations } = getSqliteInfo(sqliteSchema, sqliteTables);
-    const seedService = new SeedService();
-    const generatedTablesGenerators = seedService.generatePossibleGenerators('sqlite', tables, relations, refinements, options);
-    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, sqliteTables, { ...options, preserveCyclicTablesData });
-    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
-    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, sqliteTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
-};
-const getSqliteInfo = (sqliteSchema, sqliteTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(sqliteTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig$2(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
-    };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig$2(drizzleRel.sourceTable);
-                const tableDbName = tableConfig.name;
-                // TODO: tableNamesMap: have {public.customer: 'customer'} structure in sqlite
-                const tableTsName = schemaConfig.tableNamesMap[`public.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig$2(drizzleRel.referencedTable);
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`public.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
-            }
-        }
-        return relations;
-    };
-    for (const table of Object.values(sqliteTables)) {
-        tableConfig = getTableConfig$2(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        const newRelations = tableConfig.foreignKeys.map((fk) => {
-            const table = dbToTsTableNamesMap[tableConfig.name];
-            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
-            }
-            return {
-                table,
-                columns: fk
-                    .reference()
-                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
-                refTable,
-                refColumns: fk
-                    .reference()
-                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
-                refTableRels: tableRelations[refTable],
-            };
-        });
-        relations.push(...newRelations);
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
-        }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        const getTypeParams = (sqlType) => {
-            // get type params and set only type
-            const typeParams = {};
-            if (sqlType.startsWith('decimal')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
-            }
-            else if (sqlType.startsWith('char')
-                || sqlType.startsWith('varchar')
-                || sqlType.startsWith('text')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
-            }
-            return typeParams;
-        };
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
+    else {
+        throw new Error('The drizzle-seed package currently supports only PostgreSQL, MySQL, SQLite, Ms Sql, CockroachDB and SingleStore databases. Please ensure your database is one of these supported types');
     }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(sqliteSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const isCyclicRelations = relations.map((relI) => {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
-        }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: isCyclicRelations, tableRelations };
-};
+}
 
-export { AbstractGenerator, SeedService, cityNames as cities, countries, firstNames, getGeneratorsFunctions, lastNames, reset, seed, seedForDrizzleStudio };
+export { SeedService, cityNames as cities, countries, firstNames, getGeneratorsFunctions, lastNames, reset, seed, seedForDrizzleStudio };
 //# sourceMappingURL=index.mjs.map