drizzle-seed 0.3.2-f8a2f3c → 0.4.0-08bb2d5

package/index.cjs

@@ -4,6 +4,9 @@ var drizzleOrm = require('drizzle-orm');
 var mysqlCore = require('drizzle-orm/mysql-core');
 var pgCore = require('drizzle-orm/pg-core');
 var sqliteCore = require('drizzle-orm/sqlite-core');
+var mssqlCore = require('drizzle-orm/mssql-core');
+var cockroachCore = require('drizzle-orm/cockroach-core');
+var singlestoreCore = require('drizzle-orm/singlestore-core');
 var prand = require('pure-rand');
 
 /**
@@ -131132,18 +131135,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);
@@ -131167,16 +131212,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"]
@@ -131213,12 +131248,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 {
@@ -131234,10 +131284,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;
@@ -131269,6 +131320,7 @@ class AbstractGenerator {
             });
             uniqueGen.isUnique = this.isUnique;
             uniqueGen.dataType = this.dataType;
+            uniqueGen.typeParams = this.typeParams;
             return uniqueGen;
         }
         return;
@@ -131279,10 +131331,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;
@@ -131537,6 +131592,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;
@@ -131790,20 +131846,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);
@@ -131816,9 +131865,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() {
@@ -131840,83 +131886,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, '');
     }
 }
@@ -131926,46 +131907,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()
@@ -131981,46 +131934,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()
@@ -132376,8 +132301,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 };
     }
@@ -132400,8 +132325,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 });
@@ -132424,8 +132349,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 };
     }
@@ -132446,8 +132371,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 });
@@ -132469,8 +132394,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 };
     }
@@ -132498,8 +132423,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();
@@ -132542,8 +132467,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({
@@ -132576,8 +132501,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)];
@@ -132622,8 +132547,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.');
@@ -132700,8 +132625,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 };
     }
@@ -132723,8 +132648,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 });
@@ -132745,8 +132670,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 };
     }
@@ -132768,8 +132693,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 };
     }
@@ -132798,8 +132723,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"]
@@ -132855,8 +132780,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 };
     }
@@ -132877,8 +132802,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 });
@@ -132902,8 +132827,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 };
     }
@@ -132953,8 +132878,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;
@@ -132990,8 +132915,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 };
     }
@@ -133019,8 +132944,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 };
     }
@@ -133064,8 +132989,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
@@ -133141,8 +133066,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 };
     }
@@ -133248,6 +133173,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,
@@ -133334,6 +133260,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,
@@ -133377,6 +133304,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 {
@@ -133463,8 +133781,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)
@@ -133486,6 +133804,8 @@ class GenerateStringV2 extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
+        if (this.dataType === 'buffer')
+            return Buffer.from(currStr);
         return currStr;
     }
 }
@@ -133499,8 +133819,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;
         }
@@ -133693,8 +134013,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
@@ -133702,7 +134020,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()
      *      },
      *    },
      *  }));
@@ -133712,8 +134030,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
@@ -133721,7 +134037,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()
      *      },
      *    },
      *  }));
@@ -133731,8 +134047,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
@@ -133740,7 +134054,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()
      *      },
      *    },
      *  }));
@@ -134200,8 +134514,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,
 };
@@ -134359,10 +134797,1128 @@ 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;
+        }
+        // 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;
+        }
+        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 === '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;
+};
+
+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));
+};
+
 /* eslint-disable drizzle-internal/require-entity-kind */
 class SeedService {
     static entityKind = 'SeedService';
@@ -134373,6 +135929,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;
@@ -134412,7 +135969,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;
@@ -134468,29 +136024,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
@@ -134536,17 +136080,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;
@@ -134561,7 +136115,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);
             }
         }
@@ -134572,7 +136126,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];
@@ -134588,7 +136142,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) => {
@@ -134699,474 +136254,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 = {};
@@ -135178,7 +136265,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;
@@ -135272,7 +136360,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;
@@ -135340,7 +136430,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,
@@ -135365,10 +136458,13 @@ class SeedService {
         else if (drizzleOrm.is(db, (mysqlCore.MySqlDatabase))) {
             maxParametersNumber = this.mysqlMaxParametersNumber;
         }
-        else {
-            // is(db, BaseSQLiteDatabase<any, any>)
+        else if (drizzleOrm.is(db, (sqliteCore.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)
@@ -135453,249 +136549,726 @@ class SeedService {
                 .insert(schema[tableName])
                 .values(generatedValues);
         }
+        else if (drizzleOrm.is(db, (mssqlCore.MsSqlDatabase))) {
+            let schemaDbName;
+            let tableDbName;
+            if (override === true) {
+                const tableConfig = mssqlCore.getTableConfig(schema[tableName]);
+                schemaDbName = tableConfig.schema ?? 'dbo';
+                tableDbName = tableConfig.name;
+                await db.execute(drizzleOrm.sql.raw(`SET IDENTITY_INSERT [${schemaDbName}].[${tableDbName}] ON;`));
+            }
+            await db
+                .insert(schema[tableName])
+                .values(generatedValues);
+            if (override === true) {
+                await db.execute(drizzleOrm.sql.raw(`SET IDENTITY_INSERT [${schemaDbName}].[${tableDbName}] OFF;`));
+            }
+        }
+        else if (drizzleOrm.is(db, (cockroachCore.CockroachDatabase))) {
+            const query = db
+                .insert(schema[tableName])
+                .values(generatedValues);
+            await query;
+        }
+        else if (drizzleOrm.is(db, (singlestoreCore.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 (drizzleOrm.is(db, (pgCore.PgDatabase))) {
             const table = schema[tableName];
             const uniqueNotNullCol = table[uniqueNotNullColName];
-            await db.update(table).set(generatedValues[0]).where(drizzleOrm.eq(uniqueNotNullCol, generatedValues[0][uniqueNotNullColName]));
+            await db.update(table).set(values).where(drizzleOrm.eq(uniqueNotNullCol, uniqueNotNullColValue));
         }
         else if (drizzleOrm.is(db, (mysqlCore.MySqlDatabase))) {
             const table = schema[tableName];
-            await db.update(table).set(generatedValues[0]).where(drizzleOrm.eq(table[uniqueNotNullColName], generatedValues[0][uniqueNotNullColName]));
+            await db.update(table).set(values).where(drizzleOrm.eq(table[uniqueNotNullColName], uniqueNotNullColValue));
         }
         else if (drizzleOrm.is(db, (sqliteCore.BaseSQLiteDatabase))) {
             const table = schema[tableName];
-            await db.update(table).set(generatedValues[0]).where(drizzleOrm.eq(table[uniqueNotNullColName], generatedValues[0][uniqueNotNullColName]));
+            await db.update(table).set(values).where(drizzleOrm.eq(table[uniqueNotNullColName], uniqueNotNullColValue));
+        }
+        else if (drizzleOrm.is(db, (mssqlCore.MsSqlDatabase))) {
+            const table = schema[tableName];
+            await db.update(table).set(values).where(drizzleOrm.eq(table[uniqueNotNullColName], uniqueNotNullColValue));
+        }
+        else if (drizzleOrm.is(db, (cockroachCore.CockroachDatabase))) {
+            const table = schema[tableName];
+            await db.update(table).set(values).where(drizzleOrm.eq(table[uniqueNotNullColName], uniqueNotNullColValue));
+        }
+        else if (drizzleOrm.is(db, (singlestoreCore.SingleStoreDatabase))) {
+            const table = schema[tableName];
+            await db.update(table).set(values).where(drizzleOrm.eq(table[uniqueNotNullColName], uniqueNotNullColValue));
         }
     };
 }
 
-/* eslint-disable drizzle-internal/require-entity-kind */
-class SeedPromise {
-    db;
-    schema;
-    options;
-    static entityKind = 'SeedPromise';
-    [Symbol.toStringTag] = 'SeedPromise';
-    constructor(db, schema, options) {
-        this.db = db;
-        this.schema = schema;
-        this.options = options;
-    }
-    then(onfulfilled, onrejected) {
-        return seedFunc(this.db, this.schema, this.options).then(onfulfilled, onrejected);
-    }
-    catch(onrejected) {
-        return this.then(undefined, onrejected);
-    }
-    finally(onfinally) {
-        return this.then((value) => {
-            onfinally?.();
-            return value;
-        }, (reason) => {
-            onfinally?.();
-            throw reason;
+// Cockroach-----------------------------------------------------------------------------------------------------------
+const resetCockroach = async (db, cockroachTables) => {
+    const tablesToTruncate = Object.entries(cockroachTables).map(([_, table]) => {
+        const config = cockroachCore.getTableConfig(table);
+        config.schema = config.schema === undefined ? 'public' : config.schema;
+        return `"${config.schema}"."${config.name}"`;
+    });
+    await db.execute(drizzleOrm.sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
+};
+const filterCockroachSchema = (schema) => {
+    const cockroachSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], cockroachCore.CockroachTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const cockroachTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], cockroachCore.CockroachTable)));
+    return { cockroachSchema, cockroachTables };
+};
+const seedCockroach = async (db, schema, options = {}, refinements) => {
+    const seedService = new SeedService();
+    const { cockroachSchema, cockroachTables } = filterCockroachSchema(schema);
+    const { tables, relations } = getCockroachInfo(cockroachSchema, cockroachTables);
+    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 getCockroachInfo = (cockroachSchema, cockroachTables) => {
+    let tableConfig;
+    let dbToTsColumnNamesMap;
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(cockroachTables).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
+    const tables = [];
+    const relations = [];
+    const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
+    const getDbToTsColumnNamesMap = (table) => {
+        let dbToTsColumnNamesMap = {};
+        const tableName = drizzleOrm.getTableName(table);
+        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
+            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
+            return dbToTsColumnNamesMap;
+        }
+        const tableConfig = cockroachCore.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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
+                    continue;
+                const tableConfig = cockroachCore.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 = cockroachCore.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(cockroachTables)) {
+        tableConfig = cockroachCore.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[drizzleOrm.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],
+            };
         });
-    }
-    async refine(callback) {
-        const refinements = this.options?.version === undefined || this.options.version === '2'
-            ? callback(generatorsFuncsV2)
-            : callback(generatorsFuncs);
-        await seedFunc(this.db, this.schema, this.options, refinements);
-    }
-}
-function getGeneratorsFunctions() {
-    return generatorsFuncs;
-}
-async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleStudioRelations, schemasRefinements, options }) {
-    const generatedSchemas = {};
-    let tables, relations, refinements;
-    drizzleStudioRelations = drizzleStudioRelations.filter((rel) => rel.type === 'one');
-    for (const [schemaName, { tables: drizzleStudioTables }] of Object.entries(drizzleStudioObject)) {
-        tables = [];
-        for (const [tableName, table] of Object.entries(drizzleStudioTables)) {
-            const drizzleStudioColumns = Object.values(table.columns);
-            const columns = drizzleStudioColumns.map((col) => ({
-                name: col.name,
-                dataType: 'string',
-                columnType: col.type,
-                // TODO: revise later
-                typeParams: {},
-                default: col.default,
-                hasDefault: col.default === undefined ? false : true,
-                isUnique: col.isUnique === undefined ? false : col.isUnique,
-                notNull: col.notNull,
-                primary: col.primaryKey,
-            }));
-            tables.push({
-                name: tableName,
-                columns,
-                primaryKeys: drizzleStudioColumns.filter((col) => col.primaryKey === true).map((col) => col.name),
-            });
+        relations.push(...newRelations);
+        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
+            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
         }
-        relations = drizzleStudioRelations.filter((rel) => rel.schema === schemaName && rel.refSchema === schemaName);
-        const isCyclicRelations = relations.map((reli) => {
-            if (relations.some((relj) => reli.table === relj.refTable && reli.refTable === relj.table)) {
-                return { ...reli, isCyclic: true };
+        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;
+                }
             }
-            return { ...reli, isCyclic: false };
+            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);
+        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]),
         });
-        refinements = schemasRefinements !== undefined && schemasRefinements[schemaName] !== undefined
-            ? schemasRefinements[schemaName]
-            : undefined;
-        const seedService = new SeedService();
-        const generatedTablesGenerators = seedService.generatePossibleGenerators(sqlDialect, tables, isCyclicRelations, refinements, options);
-        const generatedTables = await seedService.generateTablesValues(isCyclicRelations, generatedTablesGenerators, undefined, undefined, { ...options, preserveData: true, insertDataInDb: false });
-        generatedSchemas[schemaName] = { tables: generatedTables };
-    }
-    return generatedSchemas;
-}
-/**
- * @param db - database you would like to seed.
- * @param schema - object that contains all your database tables you would like to seed.
- * @param options - object that contains properties `count` and `seed`:
- *
- *  `count` - number of rows you want to generate.
- *
- *  `seed` - a number that controls the state of generated data. (if the `seed` number is the same and nothing is changed in the seeding script, generated data will remain the same each time you seed database)
- *
- * @returns SeedPromise - a class object that has a refine method that is used to change generators for columns.
- *
- * @example
- * ```ts
- * // base seeding
- * await seed(db, schema);
- *
- * // seeding with count specified
- * await seed(db, schema, { count: 100000 });
- *
- * // seeding with count and seed specified
- * await seed(db, schema, { count: 100000, seed: 1 });
- *
- * // seeding using refine
- * await seed(db, schema, { count: 1000 }).refine((funcs) => ({
- *   users: {
- *     columns: {
- *       name: funcs.firstName({ isUnique: true }),
- *       email: funcs.email(),
- *       phone: funcs.phoneNumber({ template: "+380 99 ###-##-##" }),
- *       password: funcs.string({ isUnique: true }),
- *     },
- *     count: 100000,
- *   },
- *   posts: {
- *     columns: {
- *       title: funcs.valuesFromArray({
- *         values: ["Title1", "Title2", "Title3", "Title4", "Title5"],
- *       }),
- *       content: funcs.loremIpsum({ sentencesCount: 3 }),
- *     },
- *   },
- * }));
- *
- * // 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) {
-    return new SeedPromise(db, schema, options);
-}
-const seedFunc = async (db, schema, options = {}, refinements) => {
-    let version;
-    if (options?.version !== undefined) {
-        version = Number(options?.version);
-    }
-    if (drizzleOrm.is(db, (pgCore.PgDatabase))) {
-        await seedPostgres(db, schema, { ...options, version }, refinements);
-    }
-    else if (drizzleOrm.is(db, (mysqlCore.MySqlDatabase))) {
-        await seedMySql(db, schema, { ...options, version }, refinements);
     }
-    else if (drizzleOrm.is(db, (sqliteCore.BaseSQLiteDatabase))) {
-        await seedSqlite(db, schema, { ...options, version }, refinements);
+    const transformedDrizzleRelations = transformFromDrizzleRelation(cockroachSchema, 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 };
+};
+
+// MySql-----------------------------------------------------------------------------------------------------
+const resetMsSql = async (db, schema) => {
+    const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+        const tableConfig = mssqlCore.getTableConfig(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(drizzleOrm.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(drizzleOrm.sql.raw(dropFkConstraints));
+        }
+        // truncating
+        const truncateTable = `truncate table [${table.dbSchema}].[${table.dbName}];`;
+        await db.execute(drizzleOrm.sql.raw(truncateTable));
     }
-    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');
+    // 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(drizzleOrm.sql.raw(addFkConstraints));
+        }
     }
-    return;
 };
-/**
- * deletes all data from specified tables
- *
- * @param db - database you would like to reset.
- * @param schema - object that contains all your database tables you would like to delete data from.
- *
- * `If db is a PgDatabase object`, we will execute sql query and delete data from your tables the following way:
- * ```sql
- * truncate tableName1, tableName2, ... cascade;
- * ```
- *
- * `If db is a MySqlDatabase object`, we will execute sql queries and delete data from your tables the following way:
- * ```sql
- * SET FOREIGN_KEY_CHECKS = 0;
- * truncate tableName1;
- * truncate tableName2;
- * .
- * .
- * .
- *
- * SET FOREIGN_KEY_CHECKS = 1;
- * ```
- *
- * `If db is a BaseSQLiteDatabase object`, we will execute sql queries and delete data from your tables the following way:
- * ```sql
- * PRAGMA foreign_keys = OFF;
- * delete from tableName1;
- * delete from tableName2;
- * .
- * .
- * .
- *
- * PRAGMA foreign_keys = ON;
- * ```
- *
- * @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) {
-    if (drizzleOrm.is(db, (pgCore.PgDatabase))) {
-        const { pgTables } = filterPgSchema(schema);
-        if (Object.entries(pgTables).length > 0) {
-            await resetPostgres(db, pgTables);
+const filterMsSqlTables = (schema) => {
+    const mssqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mssqlCore.MsSqlTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const mssqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mssqlCore.MsSqlTable)));
+    return { mssqlSchema, mssqlTables };
+};
+const seedMsSql = async (db, schema, options = {}, refinements) => {
+    const { mssqlSchema, mssqlTables } = filterMsSqlTables(schema);
+    const { tables, relations } = getMsSqlInfo(mssqlSchema, mssqlTables);
+    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 getMsSqlInfo = (mssqlSchema, mssqlTables) => {
+    let tableConfig;
+    let dbToTsColumnNamesMap;
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(mssqlTables).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
+    const tables = [];
+    const relations = [];
+    const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
+    const getDbToTsColumnNamesMap = (table) => {
+        let dbToTsColumnNamesMap = {};
+        const tableName = drizzleOrm.getTableName(table);
+        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
+            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
+            return dbToTsColumnNamesMap;
         }
-    }
-    else if (drizzleOrm.is(db, (mysqlCore.MySqlDatabase))) {
-        const { mysqlTables } = filterMysqlTables(schema);
-        if (Object.entries(mysqlTables).length > 0) {
-            await resetMySql(db, mysqlTables);
+        const tableConfig = mssqlCore.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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
+                    continue;
+                const tableConfig = mssqlCore.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 = mssqlCore.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(mssqlTables)) {
+        tableConfig = mssqlCore.getTableConfig(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[drizzleOrm.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);
+        // 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;
+        };
+        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,
+                identity: column.identity ? true : false,
+            })),
+            primaryKeys: tableConfig.columns
+                .filter((column) => column.primary)
+                .map((column) => dbToTsColumnNamesMap[column.name]),
+        });
     }
-    else if (drizzleOrm.is(db, (sqliteCore.BaseSQLiteDatabase))) {
-        const { sqliteTables } = filterSqliteTables(schema);
-        if (Object.entries(sqliteTables).length > 0) {
-            await resetSqlite(db, sqliteTables);
+    const transformedDrizzleRelations = transformFromDrizzleRelation(mssqlSchema, getDbToTsColumnNamesMap, tableRelations);
+    relations.push(...transformedDrizzleRelations);
+    const modifiedRelations = 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: modifiedRelations, tableRelations };
+};
+
+// MySql-----------------------------------------------------------------------------------------------------
+const resetMySql = async (db, schema) => {
+    const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+        const dbTableName = drizzleOrm.getTableName(table);
+        return dbTableName;
+    });
+    await db.execute(drizzleOrm.sql.raw('SET FOREIGN_KEY_CHECKS = 0;'));
+    for (const tableName of tablesToTruncate) {
+        const sqlQuery = `truncate \`${tableName}\`;`;
+        await db.execute(drizzleOrm.sql.raw(sqlQuery));
     }
-    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');
+    await db.execute(drizzleOrm.sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
+};
+const filterMysqlTables = (schema) => {
+    const mysqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const mysqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.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]) => [drizzleOrm.getTableName(value), key]));
+    const tables = [];
+    const relations = [];
+    const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
+    const getDbToTsColumnNamesMap = (table) => {
+        let dbToTsColumnNamesMap = {};
+        const tableName = drizzleOrm.getTableName(table);
+        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
+            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
+            return dbToTsColumnNamesMap;
+        }
+        const tableConfig = mysqlCore.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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
+                    continue;
+                const tableConfig = mysqlCore.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 = mysqlCore.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(mysqlTables)) {
+        tableConfig = mysqlCore.getTableConfig(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[drizzleOrm.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')
+                || 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 };
+        }
+        tableRel['isCyclic'] = false;
+        return { ...relI, isCyclic: false };
+    });
+    return { tables, relations: isCyclicRelations, tableRelations };
+};
+
 // Postgres-----------------------------------------------------------------------------------------------------------
 const resetPostgres = async (db, pgTables) => {
     const tablesToTruncate = Object.entries(pgTables).map(([_, table]) => {
@@ -135864,6 +137437,7 @@ const getPostgresInfo = (pgSchema, pgTables) => {
                 || sqlType.startsWith('bpchar')
                 || sqlType.startsWith('char')
                 || sqlType.startsWith('bit')
+                || sqlType.startsWith('vector')
                 || sqlType.startsWith('time')
                 || sqlType.startsWith('timestamp')
                 || sqlType.startsWith('interval')) {
@@ -135913,37 +137487,9 @@ const getPostgresInfo = (pgSchema, pgTables) => {
     });
     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);
-        }
-    }
-    return false;
-};
-// MySql-----------------------------------------------------------------------------------------------------
-const resetMySql = async (db, schema) => {
+
+// SingleStore-----------------------------------------------------------------------------------------------------
+const resetSingleStore = async (db, schema) => {
     const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
         const dbTableName = drizzleOrm.getTableName(table);
         return dbTableName;
@@ -135955,26 +137501,26 @@ const resetMySql = async (db, schema) => {
     }
     await db.execute(drizzleOrm.sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
 };
-const filterMysqlTables = (schema) => {
-    const mysqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
-    const mysqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable)));
-    return { mysqlSchema, mysqlTables };
+const filterSingleStoreTables = (schema) => {
+    const singleStoreSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], singlestoreCore.SingleStoreTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const singleStoreTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], singlestoreCore.SingleStoreTable)));
+    return { singleStoreSchema, singleStoreTables };
 };
-const seedMySql = async (db, schema, options = {}, refinements) => {
-    const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
-    const { tables, relations } = getMySqlInfo(mysqlSchema, mysqlTables);
+const seedSingleStore = async (db, schema, options = {}, refinements) => {
+    const { singleStoreSchema, singleStoreTables } = filterSingleStoreTables(schema);
+    const { tables, relations } = getSingleStoreInfo(singleStoreSchema, singleStoreTables);
     const seedService = new SeedService();
-    const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, refinements, options);
+    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, mysqlTables, { ...options, preserveCyclicTablesData });
+    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, mysqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, singleStoreTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getMySqlInfo = (mysqlSchema, mysqlTables) => {
+const getSingleStoreInfo = (singleStoreSchema, singleStoreTables) => {
     let tableConfig;
     let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(mysqlTables).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(singleStoreTables).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
     const tables = [];
     const relations = [];
     const dbToTsColumnNamesMapGlobal = {};
@@ -135986,7 +137532,7 @@ const getMySqlInfo = (mysqlSchema, mysqlTables) => {
             dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
             return dbToTsColumnNamesMap;
         }
-        const tableConfig = mysqlCore.getTableConfig(table);
+        const tableConfig = singlestoreCore.getTableConfig(table);
         for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
             dbToTsColumnNamesMap[col.name] = tsCol;
         }
@@ -136002,14 +137548,14 @@ const getMySqlInfo = (mysqlSchema, mysqlTables) => {
             for (const drizzleRel of Object.values(table.relations)) {
                 if (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
                     continue;
-                const tableConfig = mysqlCore.getTableConfig(drizzleRel.sourceTable);
+                const tableConfig = singlestoreCore.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 = mysqlCore.getTableConfig(drizzleRel.referencedTable);
+                const refTableConfig = singlestoreCore.getTableConfig(drizzleRel.referencedTable);
                 const refTableDbSchema = refTableConfig.schema ?? 'public';
                 const refTableDbName = refTableConfig.name;
                 const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
@@ -136042,36 +137588,42 @@ const getMySqlInfo = (mysqlSchema, mysqlTables) => {
         }
         return relations;
     };
-    for (const table of Object.values(mysqlTables)) {
-        tableConfig = mysqlCore.getTableConfig(table);
+    for (const table of Object.values(singleStoreTables)) {
+        tableConfig = singlestoreCore.getTableConfig(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[drizzleOrm.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);
+        // const newRelations = tableConfig.foreignKeys.map((fk) => {
+        // 	const table = dbToTsTableNamesMap[tableConfig.name] as string;
+        // 	const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)] as string;
+        // 	const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(
+        // 		fk.reference().foreignTable,
+        // 	);
+        // 	if (tableRelations[refTable] === undefined) {
+        // 		tableRelations[refTable] = [];
+        // 	}
+        // 	return {
+        // 		table,
+        // 		columns: fk
+        // 			.reference()
+        // 			.columns.map((col) => dbToTsColumnNamesMap[col.name] as string),
+        // 		refTable,
+        // 		refColumns: fk
+        // 			.reference()
+        // 			.foreignColumns.map(
+        // 				(fCol) => dbToTsColumnNamesMapForRefTable[fCol.name] as string,
+        // 			),
+        // 		refTableRels: tableRelations[refTable],
+        // 	};
+        // });
+        // relations.push(
+        // 	...newRelations,
+        // );
         if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
             tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
         }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
+        // tableRelations[dbToTsTableNamesMap[tableConfig.name] as string]!.push(...newRelations);
         const getTypeParams = (sqlType) => {
             // get type params and set only type
             const typeParams = {};
@@ -136094,6 +137646,13 @@ const getMySqlInfo = (mysqlSchema, mysqlTables) => {
                     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;
         };
         tables.push({
@@ -136115,7 +137674,7 @@ const getMySqlInfo = (mysqlSchema, mysqlTables) => {
                 .map((column) => dbToTsColumnNamesMap[column.name]),
         });
     }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(mysqlSchema, getDbToTsColumnNamesMap, tableRelations);
+    const transformedDrizzleRelations = transformFromDrizzleRelation(singleStoreSchema, getDbToTsColumnNamesMap, tableRelations);
     relations.push(...transformedDrizzleRelations);
     const isCyclicRelations = relations.map((relI) => {
         const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
@@ -136128,6 +137687,7 @@ const getMySqlInfo = (mysqlSchema, mysqlTables) => {
     });
     return { tables, relations: isCyclicRelations, tableRelations };
 };
+
 // Sqlite------------------------------------------------------------------------------------------------------------------------
 const resetSqlite = async (db, schema) => {
     const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
@@ -136310,7 +137870,243 @@ const getSqliteInfo = (sqliteSchema, sqliteTables) => {
     return { tables, relations: isCyclicRelations, tableRelations };
 };
 
-exports.AbstractGenerator = AbstractGenerator;
+class SeedPromise {
+    db;
+    schema;
+    options;
+    static entityKind = 'SeedPromise';
+    [Symbol.toStringTag] = 'SeedPromise';
+    constructor(db, schema, options) {
+        this.db = db;
+        this.schema = schema;
+        this.options = options;
+    }
+    then(onfulfilled, onrejected) {
+        return seedFunc(this.db, this.schema, this.options).then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.then(undefined, onrejected);
+    }
+    finally(onfinally) {
+        return this.then((value) => {
+            onfinally?.();
+            return value;
+        }, (reason) => {
+            onfinally?.();
+            throw reason;
+        });
+    }
+    async refine(callback) {
+        const refinements = this.options?.version === undefined || this.options.version === '2'
+            ? callback(generatorsFuncsV2)
+            : callback(generatorsFuncs);
+        await seedFunc(this.db, this.schema, this.options, refinements);
+    }
+}
+function getGeneratorsFunctions() {
+    return generatorsFuncs;
+}
+async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleStudioRelations, schemasRefinements, options }) {
+    const generatedSchemas = {};
+    let tables, relations, refinements;
+    drizzleStudioRelations = drizzleStudioRelations.filter((rel) => rel.type === 'one');
+    for (const [schemaName, { tables: drizzleStudioTables }] of Object.entries(drizzleStudioObject)) {
+        tables = [];
+        for (const [tableName, table] of Object.entries(drizzleStudioTables)) {
+            const drizzleStudioColumns = Object.values(table.columns);
+            const columns = drizzleStudioColumns.map((col) => ({
+                name: col.name,
+                dataType: 'string',
+                columnType: col.type,
+                // TODO: revise later
+                typeParams: {},
+                default: col.default,
+                hasDefault: col.default === undefined ? false : true,
+                isUnique: col.isUnique === undefined ? false : col.isUnique,
+                notNull: col.notNull,
+                primary: col.primaryKey,
+            }));
+            tables.push({
+                name: tableName,
+                columns,
+                primaryKeys: drizzleStudioColumns.filter((col) => col.primaryKey === true).map((col) => col.name),
+            });
+        }
+        relations = drizzleStudioRelations.filter((rel) => rel.schema === schemaName && rel.refSchema === schemaName);
+        const isCyclicRelations = relations.map((reli) => {
+            if (relations.some((relj) => reli.table === relj.refTable && reli.refTable === relj.table)) {
+                return { ...reli, isCyclic: true };
+            }
+            return { ...reli, isCyclic: false };
+        });
+        refinements = schemasRefinements !== undefined && schemasRefinements[schemaName] !== undefined
+            ? schemasRefinements[schemaName]
+            : undefined;
+        const seedService = new SeedService();
+        const generatedTablesGenerators = seedService.generatePossibleGenerators(sqlDialect, tables, isCyclicRelations, refinements, options);
+        const generatedTables = await seedService.generateTablesValues(isCyclicRelations, generatedTablesGenerators, undefined, undefined, { ...options, preserveData: true, insertDataInDb: false });
+        generatedSchemas[schemaName] = { tables: generatedTables };
+    }
+    return generatedSchemas;
+}
+/**
+ * @param db - database you would like to seed.
+ * @param schema - object that contains all your database tables you would like to seed.
+ * @param options - object that contains properties `count` and `seed`:
+ *
+ *  `count` - number of rows you want to generate.
+ *
+ *  `seed` - a number that controls the state of generated data. (if the `seed` number is the same and nothing is changed in the seeding script, generated data will remain the same each time you seed database)
+ *
+ * @returns SeedPromise - a class object that has a refine method that is used to change generators for columns.
+ *
+ * @example
+ * ```ts
+ * // base seeding
+ * await seed(db, schema);
+ *
+ * // seeding with count specified
+ * await seed(db, schema, { count: 100000 });
+ *
+ * // seeding with count and seed specified
+ * await seed(db, schema, { count: 100000, seed: 1 });
+ *
+ * //seeding using refine
+ * await seed(db, schema, { count: 1000 }).refine((funcs) => ({
+ *   users: {
+ *     columns: {
+ *       name: funcs.firstName({ isUnique: true }),
+ *       email: funcs.email(),
+ *       phone: funcs.phoneNumber({ template: "+380 99 ###-##-##" }),
+ *       password: funcs.string({ isUnique: true }),
+ *     },
+ *     count: 100000,
+ *   },
+ *   posts: {
+ *     columns: {
+ *       title: funcs.valuesFromArray({
+ *         values: ["Title1", "Title2", "Title3", "Title4", "Title5"],
+ *       }),
+ *       content: funcs.loremIpsum({ sentencesCount: 3 }),
+ *     },
+ *   },
+ * }));
+ *
+ * ```
+ */
+function seed(db, schema, options) {
+    return new SeedPromise(db, schema, options);
+}
+const seedFunc = async (db, schema, options = {}, refinements) => {
+    let version;
+    if (options?.version !== undefined) {
+        version = Number(options?.version);
+    }
+    if (drizzleOrm.is(db, (pgCore.PgDatabase))) {
+        await seedPostgres(db, schema, { ...options, version }, refinements);
+    }
+    else if (drizzleOrm.is(db, (mysqlCore.MySqlDatabase))) {
+        await seedMySql(db, schema, { ...options, version }, refinements);
+    }
+    else if (drizzleOrm.is(db, (sqliteCore.BaseSQLiteDatabase))) {
+        await seedSqlite(db, schema, { ...options, version }, refinements);
+    }
+    else if (drizzleOrm.is(db, (mssqlCore.MsSqlDatabase))) {
+        await seedMsSql(db, schema, { ...options, version }, refinements);
+    }
+    else if (drizzleOrm.is(db, (cockroachCore.CockroachDatabase))) {
+        await seedCockroach(db, schema, { ...options, version }, refinements);
+    }
+    else if (drizzleOrm.is(db, (singlestoreCore.SingleStoreDatabase))) {
+        await seedSingleStore(db, schema, { ...options, version }, refinements);
+    }
+    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');
+    }
+    return;
+};
+/**
+ * deletes all data from specified tables
+ *
+ * @param db - database you would like to reset.
+ * @param schema - object that contains all your database tables you would like to delete data from.
+ *
+ * `If db is a PgDatabase object`, we will execute sql query and delete data from your tables the following way:
+ * ```sql
+ * truncate tableName1, tableName2, ... cascade;
+ * ```
+ *
+ * `If db is a MySqlDatabase object`, we will execute sql queries and delete data from your tables the following way:
+ * ```sql
+ * SET FOREIGN_KEY_CHECKS = 0;
+ * truncate tableName1;
+ * truncate tableName2;
+ * .
+ * .
+ * .
+ *
+ * SET FOREIGN_KEY_CHECKS = 1;
+ * ```
+ *
+ * `If db is a BaseSQLiteDatabase object`, we will execute sql queries and delete data from your tables the following way:
+ * ```sql
+ * PRAGMA foreign_keys = OFF;
+ * delete from tableName1;
+ * delete from tableName2;
+ * .
+ * .
+ * .
+ *
+ * PRAGMA foreign_keys = ON;
+ * ```
+ *
+ * @example
+ * ```ts
+ * await reset(db, schema);
+ * ```
+ */
+async function reset(db, schema) {
+    if (drizzleOrm.is(db, (pgCore.PgDatabase))) {
+        const { pgTables } = filterPgSchema(schema);
+        if (Object.entries(pgTables).length > 0) {
+            await resetPostgres(db, pgTables);
+        }
+    }
+    else if (drizzleOrm.is(db, (mysqlCore.MySqlDatabase))) {
+        const { mysqlTables } = filterMysqlTables(schema);
+        if (Object.entries(mysqlTables).length > 0) {
+            await resetMySql(db, mysqlTables);
+        }
+    }
+    else if (drizzleOrm.is(db, (sqliteCore.BaseSQLiteDatabase))) {
+        const { sqliteTables } = filterSqliteTables(schema);
+        if (Object.entries(sqliteTables).length > 0) {
+            await resetSqlite(db, sqliteTables);
+        }
+    }
+    else if (drizzleOrm.is(db, (mssqlCore.MsSqlDatabase))) {
+        const { mssqlTables } = filterMsSqlTables(schema);
+        if (Object.entries(mssqlTables).length > 0) {
+            await resetMsSql(db, mssqlTables);
+        }
+    }
+    else if (drizzleOrm.is(db, (cockroachCore.CockroachDatabase))) {
+        const { cockroachTables } = filterCockroachSchema(schema);
+        if (Object.entries(cockroachTables).length > 0) {
+            await resetCockroach(db, cockroachTables);
+        }
+    }
+    else if (drizzleOrm.is(db, (singlestoreCore.SingleStoreDatabase))) {
+        const { singleStoreTables } = filterSingleStoreTables(schema);
+        if (Object.entries(singleStoreTables).length > 0) {
+            await resetSingleStore(db, singleStoreTables);
+        }
+    }
+    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');
+    }
+}
+
 exports.SeedService = SeedService;
 exports.cities = cityNames;
 exports.countries = countries;