drizzle-seed 0.3.2-b5a9650 → 0.4.0-02522e1

package/{services → generators}/Generators.d.cts

@@ -1,20 +1,25 @@
 import prand from 'pure-rand';
+import type { GeneratedValueType } from '../types/seedService.js';
+import type { Column } from '../types/tables.js';
 export declare abstract class AbstractGenerator<T = {}> {
     static readonly entityKind: string;
     static readonly version: number;
+    isGeneratorUnique: boolean;
     isUnique: boolean;
     notNull: boolean;
     uniqueVersionOfGen?: new (params: T) => AbstractGenerator<T>;
+    maxUniqueCount: number;
     dataType?: string;
     timeSpent?: number;
     arraySize?: number;
     baseColumnDataType?: string;
-    stringLength?: number;
     weightedCountSeed?: number | undefined;
     maxRepeatedValuesCount?: number | {
         weight: number;
         count: number | number[];
     }[] | undefined;
+    typeParams: Column['typeParams'];
+    uniqueKey?: string;
     params: T;
     constructor(params?: T);
     init(params: {
@@ -26,12 +31,22 @@ export declare abstract class AbstractGenerator<T = {}> {
     }): void;
     updateParams(): void;
     abstract generate(params: {
-        i: number;
+        i?: number;
+        columnName?: string;
+        input?: string;
     }): number | string | boolean | unknown | undefined | void;
     getEntityKind(): string;
+    getMaxUniqueCount(): number;
     replaceIfUnique(): AbstractGenerator<T> | undefined;
     replaceIfArray(): GenerateArray | undefined;
 }
+export declare class GenerateHashFromString extends AbstractGenerator<{}> {
+    static readonly entityKind: string;
+    init(): void;
+    generate({ input }: {
+        input: string;
+    }): number;
+}
 export declare class GenerateArray extends AbstractGenerator<{
     baseColumnGen: AbstractGenerator<any>;
     size?: number;
@@ -68,17 +83,22 @@ export declare class GenerateDefault extends AbstractGenerator<{
     static readonly entityKind: string;
     generate(): unknown;
 }
-export declare class GenerateValuesFromArray extends AbstractGenerator<{
-    values: (number | string | boolean | undefined)[] | {
+export type GenerateValuesFromArrayT = {
+    values: GeneratedValueType[] | {
         weight: number;
-        values: (number | string | boolean | undefined)[];
+        values: GeneratedValueType[];
     }[];
     isUnique?: boolean;
     arraySize?: number;
-}> {
+};
+export declare class GenerateValuesFromArray extends AbstractGenerator<GenerateValuesFromArrayT> {
     static readonly entityKind: string;
     private state;
     timeSpent: number;
+    maxUniqueCount: number;
+    private allValuesCount;
+    constructor(params?: GenerateValuesFromArrayT);
+    getMaxUniqueCount(): number;
     checks({ count }: {
         count: number;
     }): void;
@@ -89,7 +109,7 @@ export declare class GenerateValuesFromArray extends AbstractGenerator<{
     generate(): string | number | boolean | undefined;
 }
 export declare class GenerateSelfRelationsValuesFromArray extends AbstractGenerator<{
-    values: (number | string | boolean)[];
+    values: (number | string | bigint)[];
 }> {
     static readonly entityKind: string;
     private state;
@@ -99,11 +119,13 @@ export declare class GenerateSelfRelationsValuesFromArray extends AbstractGenera
     }): void;
     generate({ i }: {
         i: number;
-    }): string | number | boolean | undefined;
+    }): string | number | bigint | undefined;
 }
 export declare class GenerateIntPrimaryKey extends AbstractGenerator<{}> {
     static readonly entityKind: string;
     maxValue?: number | bigint;
+    maxUniqueCount: number;
+    isGeneratorUnique: boolean;
     init({ count }: {
         count: number;
         seed: number;
@@ -128,15 +150,20 @@ export declare class GenerateNumber extends AbstractGenerator<{
     }): void;
     generate(): number;
 }
-export declare class GenerateUniqueNumber extends AbstractGenerator<{
+export type GenerateUniqueNumberT = {
     minValue?: number;
     maxValue?: number;
     precision?: number;
     isUnique?: boolean;
-}> {
+};
+export declare class GenerateUniqueNumber extends AbstractGenerator<GenerateUniqueNumberT> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    precision: number;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    constructor(params?: GenerateUniqueNumberT);
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -158,11 +185,12 @@ export declare class GenerateInt extends AbstractGenerator<{
     }): void;
     generate(): string | number | bigint;
 }
-export declare class GenerateUniqueInt extends AbstractGenerator<{
+export type GenerateUniqueIntT = {
     minValue?: number | bigint;
     maxValue?: number | bigint;
     isUnique?: boolean;
-}> {
+};
+export declare class GenerateUniqueInt extends AbstractGenerator<GenerateUniqueIntT> {
     static readonly entityKind: string;
     genMaxRepeatedValuesCount: GenerateDefault | GenerateWeightedCount | undefined;
     skipCheck?: boolean;
@@ -173,8 +201,11 @@ export declare class GenerateUniqueInt extends AbstractGenerator<{
         intervals: (number | bigint)[][];
         integersCount: Map<number | bigint, number>;
     } | undefined;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
     timeSpent: number;
+    maxUniqueCount: number;
+    constructor(params?: GenerateUniqueIntT);
+    getMaxUniqueCount<T extends number | bigint>(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -208,8 +239,6 @@ export declare class GenerateDate extends AbstractGenerator<{
     generate(): string | Date;
 }
 export declare class GenerateTime extends AbstractGenerator<{
-    minTime?: string | Date;
-    maxTime?: string | Date;
     arraySize?: number;
 }> {
     static readonly entityKind: string;
@@ -232,8 +261,6 @@ export declare class GenerateTimestampInt extends AbstractGenerator<{
     generate(): number;
 }
 export declare class GenerateTimestamp extends AbstractGenerator<{
-    minTimestamp?: string | Date;
-    maxTimestamp?: string | Date;
     arraySize?: number;
 }> {
     static readonly entityKind: string;
@@ -245,8 +272,6 @@ export declare class GenerateTimestamp extends AbstractGenerator<{
     generate(): string | Date;
 }
 export declare class GenerateDatetime extends AbstractGenerator<{
-    minDatetime?: string | Date;
-    maxDatetime?: string | Date;
     arraySize?: number;
 }> {
     static readonly entityKind: string;
@@ -323,14 +348,18 @@ export declare class GenerateInterval extends AbstractGenerator<{
     }): void;
     generate(): string;
 }
-export declare class GenerateUniqueInterval extends AbstractGenerator<{
+export type GenerateUniqueIntervalT = {
     fields?: 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'year to month' | 'day to hour' | 'day to minute' | 'day to second' | 'hour to minute' | 'hour to second' | 'minute to second';
     isUnique?: boolean;
-}> {
+};
+export declare class GenerateUniqueInterval extends AbstractGenerator<GenerateUniqueIntervalT> {
     static readonly 'entityKind': string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
     private config;
+    maxUniqueCount: number;
+    constructor(params?: GenerateUniqueIntervalT);
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -348,27 +377,31 @@ export declare class GenerateString extends AbstractGenerator<{
         count: number;
         seed: number;
     }): void;
-    generate(): string;
+    generate(): string | Buffer<ArrayBuffer>;
 }
 export declare class GenerateUniqueString extends AbstractGenerator<{
     isUnique?: boolean;
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    getMaxUniqueCount(): number;
     init({ seed }: {
         seed: number;
     }): void;
     generate({ i }: {
         i: number;
-    }): string;
+    }): string | Buffer<ArrayBuffer>;
 }
 export declare class GenerateUUID extends AbstractGenerator<{
     arraySize?: number;
 }> {
     static readonly entityKind: string;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
     private state;
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -394,7 +427,9 @@ export declare class GenerateUniqueFirstName extends AbstractGenerator<{
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -419,7 +454,9 @@ export declare class GenerateUniqueLastName extends AbstractGenerator<{
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -444,8 +481,10 @@ export declare class GenerateUniqueFullName extends AbstractGenerator<{
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
     timeSpent: number;
+    maxUniqueCount: number;
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -458,22 +497,35 @@ export declare class GenerateEmail extends AbstractGenerator<{
     static readonly entityKind: string;
     private state;
     timeSpent: number;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
     }): void;
     generate(): string;
 }
-export declare class GeneratePhoneNumber extends AbstractGenerator<{
+export type GeneratePhoneNumberT = {
     template?: string;
     prefixes?: string[];
     generatedDigitsNumbers?: number | number[];
     arraySize?: number;
-}> {
+};
+export declare class GeneratePhoneNumber extends AbstractGenerator<GeneratePhoneNumberT> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    constructor(params?: GeneratePhoneNumberT);
+    prepareWithTemplate(): {
+        placeholdersCount: number;
+    };
+    prepareWithoutTemplate(): {
+        generatedDigitsNumbers: number[];
+        prefixes: string[];
+    };
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -498,7 +550,9 @@ export declare class GenerateUniqueCountry extends AbstractGenerator<{
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -534,7 +588,10 @@ export declare class GenerateUniqueStreetAddress extends AbstractGenerator<{
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    streetNumbersCount: number;
+    maxUniqueCount: number;
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -559,7 +616,8 @@ export declare class GenerateUniqueCity extends AbstractGenerator<{
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -584,7 +642,8 @@ export declare class GenerateUniquePostcode extends AbstractGenerator<{
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -620,7 +679,8 @@ export declare class GenerateUniqueCompanyName extends AbstractGenerator<{
 }> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -673,16 +733,21 @@ export declare class GeneratePoint extends AbstractGenerator<{
         y: number;
     };
 }
-export declare class GenerateUniquePoint extends AbstractGenerator<{
+export type GenerateUniquePointT = {
     minXValue?: number;
     maxXValue?: number;
     minYValue?: number;
     maxYValue?: number;
     isUnique?: boolean;
-}> {
+};
+export declare class GenerateUniquePoint extends AbstractGenerator<GenerateUniquePointT> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    xCoordinateGen: GenerateUniqueNumber;
+    yCoordinateGen: GenerateUniqueNumber;
+    maxUniqueCount: number;
+    constructor(params?: GenerateUniquePointT);
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -715,7 +780,7 @@ export declare class GenerateLine extends AbstractGenerator<{
         c: number;
     };
 }
-export declare class GenerateUniqueLine extends AbstractGenerator<{
+export type GenerateUniqueLineT = {
     minAValue?: number;
     maxAValue?: number;
     minBValue?: number;
@@ -723,10 +788,16 @@ export declare class GenerateUniqueLine extends AbstractGenerator<{
     minCValue?: number;
     maxCValue?: number;
     isUnique?: boolean;
-}> {
+};
+export declare class GenerateUniqueLine extends AbstractGenerator<GenerateUniqueLineT> {
     static readonly entityKind: string;
     private state;
-    isUnique: boolean;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    aCoefficientGen: GenerateUniqueNumber;
+    bCoefficientGen: GenerateUniqueNumber;
+    cCoefficientGen: GenerateUniqueNumber;
+    constructor(params?: GenerateUniqueLineT);
     init({ count, seed }: {
         count: number;
         seed: number;
@@ -737,24 +808,184 @@ export declare class GenerateUniqueLine extends AbstractGenerator<{
         c: number;
     };
 }
-export declare class CustomGenerator<StateT extends Record<string, any> = {}> extends AbstractGenerator<{
-    generate: (params: {
-        this_: CustomGenerator;
-        i: number;
-    }) => any;
-    init?: (params: {
-        this_: CustomGenerator;
+export declare class GenerateBitString extends AbstractGenerator<{
+    dimensions?: number;
+    isUnique?: boolean;
+    arraySize?: number;
+}> {
+    static readonly entityKind: string;
+    dimensions: number;
+    private state;
+    uniqueVersionOfGen: typeof GenerateUniqueBitString;
+    init({ count, seed }: {
         count: number;
         seed: number;
-    }) => void;
+    }): void;
+    generate(): string;
+}
+export declare class GenerateUniqueBitString extends AbstractGenerator<{
+    dimensions?: number;
+    isUnique?: boolean;
+    arraySize?: number;
 }> {
-    state: StateT;
     static readonly entityKind: string;
+    dimensions: number;
+    private state;
+    isGeneratorUnique: boolean;
+    getMaxUniqueCount(): number;
     init({ count, seed }: {
         count: number;
         seed: number;
     }): void;
-    generate({ i }: {
+    generate(): string;
+}
+export declare class GenerateInet extends AbstractGenerator<{
+    ipAddress?: 'ipv4' | 'ipv6';
+    includeCidr?: boolean;
+    isUnique?: boolean;
+    arraySize?: number;
+}> {
+    static readonly entityKind: string;
+    ipAddress: 'ipv4' | 'ipv6';
+    includeCidr: boolean;
+    private state;
+    uniqueVersionOfGen: typeof GenerateUniqueInet;
+    init({ count, seed }: {
+        count: number;
+        seed: number;
+    }): void;
+    generate(): string;
+}
+export type GenerateUniqueInetT = {
+    ipAddress?: 'ipv4' | 'ipv6';
+    includeCidr?: boolean;
+    isUnique?: boolean;
+    arraySize?: number;
+};
+export declare class GenerateUniqueInet extends AbstractGenerator<GenerateUniqueInetT> {
+    static readonly entityKind: string;
+    ipAddress: 'ipv4' | 'ipv6';
+    includeCidr: boolean;
+    delimiter: '.' | ':';
+    private state;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    constructor(params?: GenerateUniqueInetT);
+    init({ count, seed }: {
+        count: number;
+        seed: number;
+    }): void;
+    generate(): string;
+}
+export declare class GenerateGeometry extends AbstractGenerator<{
+    type?: 'point';
+    srid?: 4326 | 3857;
+    decimalPlaces?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    isUnique?: boolean;
+    arraySize?: number;
+}> {
+    static readonly entityKind: string;
+    type: "point";
+    srid: 4326 | 3857;
+    decimalPlaces: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    private state;
+    uniqueVersionOfGen: typeof GenerateUniqueGeometry;
+    init({ count, seed }: {
+        count: number;
+        seed: number;
+    }): void;
+    generate(): number[] | {
+        x: number;
+        y: number;
+    };
+}
+export type GenerateUniqueGeometryT = {
+    type?: 'point';
+    srid?: 4326 | 3857;
+    decimalPlaces?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    isUnique?: boolean;
+    arraySize?: number;
+};
+export declare class GenerateUniqueGeometry extends AbstractGenerator<GenerateUniqueGeometryT> {
+    static readonly entityKind: string;
+    type: "point";
+    srid: 4326 | 3857;
+    decimalPlaces: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    private state;
+    isGeneratorUnique: boolean;
+    maxUniqueCount: number;
+    constructor(params?: GenerateUniqueGeometryT);
+    init({ count, seed }: {
+        count: number;
+        seed: number;
+    }): void;
+    generate(): number[] | {
+        x: number;
+        y: number;
+    };
+}
+export declare class GenerateVector extends AbstractGenerator<{
+    dimensions?: number;
+    minValue?: number;
+    maxValue?: number;
+    decimalPlaces?: number;
+    isUnique?: boolean;
+    arraySize?: number;
+}> {
+    static readonly entityKind: string;
+    dimensions: number;
+    minValue: number;
+    maxValue: number;
+    decimalPlaces: number;
+    private state;
+    uniqueVersionOfGen: typeof GenerateUniqueVector;
+    init({ count, seed }: {
+        count: number;
+        seed: number;
+    }): void;
+    generate(): unknown[];
+}
+export type GenerateUniqueVectorT = {
+    dimensions?: number;
+    minValue?: number;
+    maxValue?: number;
+    decimalPlaces?: number;
+    isUnique?: boolean;
+    arraySize?: number;
+};
+export declare class GenerateUniqueVector extends AbstractGenerator<GenerateUniqueVectorT> {
+    static readonly entityKind: string;
+    dimensions: number;
+    minValue: number;
+    maxValue: number;
+    decimalPlaces: number;
+    private state;
+    isGeneratorUnique: boolean;
+    constructor(params?: GenerateUniqueVectorT);
+    getMaxUniqueCount(): number;
+    init({ count, seed }: {
+        count: number;
+        seed: number;
+    }): void;
+    generate(): number[];
+}
+export declare class GenerateCompositeUniqueKey extends AbstractGenerator {
+    static readonly entityKind: string;
+    columnGenerators: {
+        columnName: string;
+        generator: AbstractGenerator<any>;
+        maxUniqueCount?: number;
+        count?: number;
+    }[];
+    private isInitialized;
+    private state;
+    addGenerator(columnName: string, generator: AbstractGenerator<any>): void;
+    init({ count, seed }: {
+        count: number;
+        seed: number;
+    }): void;
+    generate({ i, columnName }: {
         i: number;
+        columnName: string;
     }): any;
 }