@drichdev/genata 1.0.0

package/dist/generators/base.js

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * Basic data generators
+ * Security: All inputs are validated and sanitized
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextGenerators = exports.DataTypeGenerators = exports.DateGenerators = exports.CompanyGenerators = exports.InternetGenerators = exports.LocationGenerators = exports.PersonGenerators = void 0;
+const faker_1 = require("../utils/faker");
+const validators_1 = require("../validators");
+exports.PersonGenerators = {
+    firstName: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.person.firstName();
+    },
+    lastName: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.person.lastName();
+    },
+    fullName: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.person.fullName();
+    },
+    email: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.internet.email().toLowerCase();
+    },
+    username: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.internet.username().toLowerCase();
+    },
+    password: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        const length = options?.length || 16;
+        if (length < 8 || length > 128) {
+            throw new Error("Password length must be between 8 and 128 characters");
+        }
+        return faker.internet.password({ length });
+    },
+    phone: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.phone.number();
+    },
+};
+exports.LocationGenerators = {
+    address: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.location.streetAddress();
+    },
+    city: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.location.city();
+    },
+    country: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.location.country();
+    },
+    zipCode: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.location.zipCode();
+    },
+};
+exports.InternetGenerators = {
+    url: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.internet.url();
+    },
+    ipv4: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.internet.ipv4();
+    },
+    ipv6: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.internet.ipv6();
+    },
+    creditCard: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.finance.creditCardNumber();
+    },
+};
+exports.CompanyGenerators = {
+    company: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.company.name();
+    },
+    jobTitle: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.person.jobTitle();
+    },
+};
+exports.DateGenerators = {
+    date: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.date.past().toISOString().split("T")[0];
+    },
+    dateTime: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.date.recent().toISOString();
+    },
+    futureDate: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.date.future().toISOString().split("T")[0];
+    },
+};
+exports.DataTypeGenerators = {
+    uuid: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.string.uuid();
+    },
+    boolean: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.datatype.boolean();
+    },
+    integer: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        const min = options?.min ?? 0;
+        const max = options?.max ?? 100;
+        if (min >= max) {
+            throw new Error("Min must be less than max");
+        }
+        return faker.number.int({ min, max });
+    },
+    float: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        const min = options?.min ?? 0;
+        const max = options?.max ?? 100;
+        const decimals = options?.decimals ?? 2;
+        if (min >= max) {
+            throw new Error("Min must be less than max");
+        }
+        if (decimals < 0 || decimals > 10) {
+            throw new Error("Decimals must be between 0 and 10");
+        }
+        return faker.number.float({ min, max, fractionDigits: decimals });
+    },
+    hex: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        const length = options?.length ?? 8;
+        if (length < 1 || length > 256) {
+            throw new Error("Hex length must be between 1 and 256");
+        }
+        return faker.string.hexadecimal({ length });
+    },
+    color: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.color.rgb();
+    },
+};
+exports.TextGenerators = {
+    sentence: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.lorem.sentence();
+    },
+    paragraph: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        const sentences = options?.sentences ?? 3;
+        if (sentences < 1 || sentences > 20) {
+            throw new Error("Sentences must be between 1 and 20");
+        }
+        return faker.lorem.paragraphs(sentences);
+    },
+    word: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.lorem.word();
+    },
+    slug: (options) => {
+        (0, validators_1.validateGeneratorOptions)(options || {});
+        const faker = (0, faker_1.getFaker)(options);
+        return faker.lorem.slug();
+    },
+};

package/dist/generators/batch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Batch data generation - Generate multiple records at once
+ */
+import type { FieldDefinition, BatchGeneratorOptions } from "../types";
+export declare function generateBatch(fields: FieldDefinition[], options?: BatchGeneratorOptions): Record<string, unknown>[];
+/**
+ * Generate a single batch with progress tracking
+ */
+export declare function generateBatchWithProgress(fields: FieldDefinition[], options?: BatchGeneratorOptions & {
+    onProgress?: (progress: number) => void;
+}): Record<string, unknown>[];
+//# sourceMappingURL=batch.d.ts.map

package/dist/generators/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/generators/batch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAIvE,wBAAgB,aAAa,CAC3B,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CA6B3B;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,CAAC,EAAE,qBAAqB,GAAG;IAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAC5E,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAiC3B"}

package/dist/generators/batch.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Batch data generation - Generate multiple records at once
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBatch = generateBatch;
+exports.generateBatchWithProgress = generateBatchWithProgress;
+const validators_1 = require("../validators");
+const field_1 = require("./field");
+function generateBatch(fields, options) {
+    (0, validators_1.validateBatchOptions)(options || {});
+    if (!Array.isArray(fields) || fields.length === 0) {
+        throw new Error("Fields must be a non-empty array");
+    }
+    // Validate all field types before generating
+    fields.forEach((field) => {
+        (0, validators_1.validateFieldType)(field.type);
+    });
+    const count = options?.count ?? 100;
+    const data = [];
+    for (let i = 0; i < count; i++) {
+        const row = {};
+        for (const field of fields) {
+            row[field.name] = (0, field_1.generateField)(field.type, {
+                ...options,
+                index: i,
+            });
+        }
+        data.push(row);
+    }
+    return data;
+}
+/**
+ * Generate a single batch with progress tracking
+ */
+function generateBatchWithProgress(fields, options) {
+    (0, validators_1.validateBatchOptions)(options || {});
+    if (!Array.isArray(fields) || fields.length === 0) {
+        throw new Error("Fields must be a non-empty array");
+    }
+    fields.forEach((field) => {
+        (0, validators_1.validateFieldType)(field.type);
+    });
+    const count = options?.count ?? 100;
+    const data = [];
+    const onProgress = options?.onProgress;
+    for (let i = 0; i < count; i++) {
+        const row = {};
+        for (const field of fields) {
+            row[field.name] = (0, field_1.generateField)(field.type, {
+                ...options,
+                index: i,
+            });
+        }
+        data.push(row);
+        if (onProgress) {
+            onProgress(Math.round(((i + 1) / count) * 100));
+        }
+    }
+    return data;
+}

package/dist/generators/field.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Field-level data generation based on field type
+ */
+import type { FieldType, GeneratorOptions } from "../types";
+interface FieldGenerationOptions extends GeneratorOptions {
+    index?: number;
+}
+export declare function generateField(type: FieldType, options?: FieldGenerationOptions): unknown;
+export {};
+//# sourceMappingURL=field.d.ts.map

package/dist/generators/field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/generators/field.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAW5D,UAAU,sBAAuB,SAAQ,gBAAgB;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,EACf,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CA8ET"}

package/dist/generators/field.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Field-level data generation based on field type
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateField = generateField;
+const base_1 = require("./base");
+function generateField(type, options) {
+    const index = options?.index ?? 0;
+    switch (type) {
+        // Personal Information
+        case "first_name":
+            return base_1.PersonGenerators.firstName(options);
+        case "last_name":
+            return base_1.PersonGenerators.lastName(options);
+        case "full_name":
+            return base_1.PersonGenerators.fullName(options);
+        case "email":
+            return base_1.PersonGenerators.email(options);
+        case "username":
+            return base_1.PersonGenerators.username(options);
+        case "password":
+            return base_1.PersonGenerators.password(options);
+        case "phone":
+            return base_1.PersonGenerators.phone(options);
+        // Location
+        case "address":
+            return base_1.LocationGenerators.address(options);
+        case "city":
+            return base_1.LocationGenerators.city(options);
+        case "country":
+            return base_1.LocationGenerators.country(options);
+        case "zip":
+            return base_1.LocationGenerators.zipCode(options);
+        // Internet
+        case "url":
+            return base_1.InternetGenerators.url(options);
+        case "ipv4":
+            return base_1.InternetGenerators.ipv4(options);
+        case "ipv6":
+            return base_1.InternetGenerators.ipv6(options);
+        case "credit_card":
+            return base_1.InternetGenerators.creditCard(options);
+        // Company
+        case "company":
+            return base_1.CompanyGenerators.company(options);
+        case "job_title":
+            return base_1.CompanyGenerators.jobTitle(options);
+        // Date/Time
+        case "date":
+            return base_1.DateGenerators.date(options);
+        case "datetime":
+            return base_1.DateGenerators.dateTime(options);
+        // Data Types
+        case "uuid":
+            return base_1.DataTypeGenerators.uuid(options);
+        case "boolean":
+            return base_1.DataTypeGenerators.boolean(options);
+        case "int":
+        case "number":
+            return base_1.DataTypeGenerators.integer(options);
+        case "float":
+            return base_1.DataTypeGenerators.float(options);
+        case "zero_one":
+            return base_1.DataTypeGenerators.integer({ ...options, min: 0, max: 1 });
+        case "id_increment":
+            return index + 1;
+        // Text
+        case "paragraph":
+            return base_1.TextGenerators.paragraph(options);
+        case "sentence":
+            return base_1.TextGenerators.sentence(options);
+        case "color":
+            return base_1.DataTypeGenerators.color(options);
+        default:
+            throw new Error(`Unknown field type: ${type}`);
+    }
+}

package/dist/generators/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generators index - Export all generators
+ */
+export { generateBatch, generateBatchWithProgress } from "./batch";
+export { generateField } from "./field";
+export { PersonGenerators, LocationGenerators, InternetGenerators, CompanyGenerators, DateGenerators, DataTypeGenerators, TextGenerators, } from "./base";
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generators/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,cAAc,GACf,MAAM,QAAQ,CAAC"}

package/dist/generators/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Generators index - Export all generators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextGenerators = exports.DataTypeGenerators = exports.DateGenerators = exports.CompanyGenerators = exports.InternetGenerators = exports.LocationGenerators = exports.PersonGenerators = exports.generateField = exports.generateBatchWithProgress = exports.generateBatch = void 0;
+var batch_1 = require("./batch");
+Object.defineProperty(exports, "generateBatch", { enumerable: true, get: function () { return batch_1.generateBatch; } });
+Object.defineProperty(exports, "generateBatchWithProgress", { enumerable: true, get: function () { return batch_1.generateBatchWithProgress; } });
+var field_1 = require("./field");
+Object.defineProperty(exports, "generateField", { enumerable: true, get: function () { return field_1.generateField; } });
+var base_1 = require("./base");
+Object.defineProperty(exports, "PersonGenerators", { enumerable: true, get: function () { return base_1.PersonGenerators; } });
+Object.defineProperty(exports, "LocationGenerators", { enumerable: true, get: function () { return base_1.LocationGenerators; } });
+Object.defineProperty(exports, "InternetGenerators", { enumerable: true, get: function () { return base_1.InternetGenerators; } });
+Object.defineProperty(exports, "CompanyGenerators", { enumerable: true, get: function () { return base_1.CompanyGenerators; } });
+Object.defineProperty(exports, "DateGenerators", { enumerable: true, get: function () { return base_1.DateGenerators; } });
+Object.defineProperty(exports, "DataTypeGenerators", { enumerable: true, get: function () { return base_1.DataTypeGenerators; } });
+Object.defineProperty(exports, "TextGenerators", { enumerable: true, get: function () { return base_1.TextGenerators; } });

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Genata Core - Main API
+ * Simple and intuitive interface for data generation
+ *
+ * Usage examples:
+ * - genata.email() - generates a random email
+ * - genata.person.firstName() - generates a first name
+ * - genata.generateBatch([...]) - generates multiple records
+ */
+import { PersonGenerators, LocationGenerators, InternetGenerators, CompanyGenerators, DateGenerators, DataTypeGenerators, TextGenerators, generateBatch, generateBatchWithProgress } from "./generators";
+import type { FieldDefinition, BatchGeneratorOptions } from "./types";
+/**
+ * Main Genata API
+ */
+declare const genata: {
+    email: () => string;
+    firstName: () => string;
+    lastName: () => string;
+    fullName: () => string;
+    username: () => string;
+    password: (options?: {
+        length?: number;
+    }) => string;
+    phone: () => string;
+    person: {
+        firstName: (options?: import("./types").GeneratorOptions) => string;
+        lastName: (options?: import("./types").GeneratorOptions) => string;
+        fullName: (options?: import("./types").GeneratorOptions) => string;
+        email: (options?: import("./types").GeneratorOptions) => string;
+        username: (options?: import("./types").GeneratorOptions) => string;
+        password: (options?: import("./types").GeneratorOptions & {
+            length?: number;
+        }) => string;
+        phone: (options?: import("./types").GeneratorOptions) => string;
+    };
+    location: {
+        address: (options?: import("./types").GeneratorOptions) => string;
+        city: (options?: import("./types").GeneratorOptions) => string;
+        country: (options?: import("./types").GeneratorOptions) => string;
+        zipCode: (options?: import("./types").GeneratorOptions) => string;
+    };
+    internet: {
+        url: (options?: import("./types").GeneratorOptions) => string;
+        ipv4: (options?: import("./types").GeneratorOptions) => string;
+        ipv6: (options?: import("./types").GeneratorOptions) => string;
+        creditCard: (options?: import("./types").GeneratorOptions) => string;
+    };
+    company: {
+        company: (options?: import("./types").GeneratorOptions) => string;
+        jobTitle: (options?: import("./types").GeneratorOptions) => string;
+    };
+    date: {
+        date: (options?: import("./types").GeneratorOptions & {
+            format?: string;
+        }) => string;
+        dateTime: (options?: import("./types").GeneratorOptions) => string;
+        futureDate: (options?: import("./types").GeneratorOptions) => string;
+    };
+    datatype: {
+        uuid: (options?: import("./types").GeneratorOptions) => string;
+        boolean: (options?: import("./types").GeneratorOptions) => boolean;
+        integer: (options?: import("./types").GeneratorOptions & {
+            min?: number;
+            max?: number;
+        }) => number;
+        float: (options?: import("./types").GeneratorOptions & {
+            min?: number;
+            max?: number;
+            decimals?: number;
+        }) => number;
+        hex: (options?: import("./types").GeneratorOptions & {
+            length?: number;
+        }) => string;
+        color: (options?: import("./types").GeneratorOptions) => string;
+    };
+    text: {
+        sentence: (options?: import("./types").GeneratorOptions) => string;
+        paragraph: (options?: import("./types").GeneratorOptions & {
+            sentences?: number;
+        }) => string;
+        word: (options?: import("./types").GeneratorOptions) => string;
+        slug: (options?: import("./types").GeneratorOptions) => string;
+    };
+    generateBatch: (fields: FieldDefinition[], options?: BatchGeneratorOptions) => Record<string, unknown>[];
+    generateBatchWithProgress: (fields: FieldDefinition[], options?: BatchGeneratorOptions & {
+        onProgress?: (progress: number) => void;
+    }) => Record<string, unknown>[];
+    setSeed: (seed: number) => void;
+    resetSeed: () => void;
+    setLocale: (locale: string) => void;
+};
+export default genata;
+export * from "./types";
+export * from "./validators";
+export { PersonGenerators, LocationGenerators, InternetGenerators, CompanyGenerators, DateGenerators, DataTypeGenerators, TextGenerators, generateBatch, generateBatchWithProgress, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,yBAAyB,EAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAItE;;GAEG;AACH,QAAA,MAAM,MAAM;;;;;;yBAOW;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;kBAOnC,CAAC;;;;;;;;;;;;;;;;;;;;;;kBA+C+3C,CAAC;;;;;;;;;eAAq+B,CAAC;eAAa,CAAC;;;eAAkW,CAAC;eAAa,CAAC;oBAAkB,CAAC;;;kBAAwhB,CAAC;;;;;;;qBAA2uB,CAAC;;;;;4BAvCz/H,eAAe,EAAE,YACf,qBAAqB;wCAIvB,eAAe,EAAE,YACf,qBAAqB,GAAG;QAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE;oBAI/D,MAAM;;wBASF,MAAM;CAI3B,CAAC;AAEF,eAAe,MAAM,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,yBAAyB,GAC1B,CAAC"}

package/dist/index.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Genata Core - Main API
+ * Simple and intuitive interface for data generation
+ *
+ * Usage examples:
+ * - genata.email() - generates a random email
+ * - genata.person.firstName() - generates a first name
+ * - genata.generateBatch([...]) - generates multiple records
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBatchWithProgress = exports.generateBatch = exports.TextGenerators = exports.DataTypeGenerators = exports.DateGenerators = exports.CompanyGenerators = exports.InternetGenerators = exports.LocationGenerators = exports.PersonGenerators = void 0;
+const generators_1 = require("./generators");
+Object.defineProperty(exports, "PersonGenerators", { enumerable: true, get: function () { return generators_1.PersonGenerators; } });
+Object.defineProperty(exports, "LocationGenerators", { enumerable: true, get: function () { return generators_1.LocationGenerators; } });
+Object.defineProperty(exports, "InternetGenerators", { enumerable: true, get: function () { return generators_1.InternetGenerators; } });
+Object.defineProperty(exports, "CompanyGenerators", { enumerable: true, get: function () { return generators_1.CompanyGenerators; } });
+Object.defineProperty(exports, "DateGenerators", { enumerable: true, get: function () { return generators_1.DateGenerators; } });
+Object.defineProperty(exports, "DataTypeGenerators", { enumerable: true, get: function () { return generators_1.DataTypeGenerators; } });
+Object.defineProperty(exports, "TextGenerators", { enumerable: true, get: function () { return generators_1.TextGenerators; } });
+Object.defineProperty(exports, "generateBatch", { enumerable: true, get: function () { return generators_1.generateBatch; } });
+Object.defineProperty(exports, "generateBatchWithProgress", { enumerable: true, get: function () { return generators_1.generateBatchWithProgress; } });
+const faker_1 = require("./utils/faker");
+const validators_1 = require("./validators");
+/**
+ * Main Genata API
+ */
+const genata = {
+    // Direct access to most common generators
+    email: () => generators_1.PersonGenerators.email(),
+    firstName: () => generators_1.PersonGenerators.firstName(),
+    lastName: () => generators_1.PersonGenerators.lastName(),
+    fullName: () => generators_1.PersonGenerators.fullName(),
+    username: () => generators_1.PersonGenerators.username(),
+    password: (options) => generators_1.PersonGenerators.password(options),
+    phone: () => generators_1.PersonGenerators.phone(),
+    // Grouped generators by category
+    person: generators_1.PersonGenerators,
+    location: generators_1.LocationGenerators,
+    internet: generators_1.InternetGenerators,
+    company: generators_1.CompanyGenerators,
+    date: generators_1.DateGenerators,
+    datatype: generators_1.DataTypeGenerators,
+    text: generators_1.TextGenerators,
+    // Batch generation
+    generateBatch: (fields, options) => (0, generators_1.generateBatch)(fields, options),
+    generateBatchWithProgress: (fields, options) => (0, generators_1.generateBatchWithProgress)(fields, options),
+    // Configuration
+    setSeed: (seed) => {
+        (0, validators_1.validateGeneratorOptions)({ seed });
+        (0, faker_1.initializeFaker)({ seed });
+    },
+    resetSeed: () => {
+        (0, faker_1.resetFaker)();
+    },
+    setLocale: (locale) => {
+        (0, validators_1.validateGeneratorOptions)({ locale });
+        (0, faker_1.initializeFaker)({ locale });
+    },
+};
+exports.default = genata;
+__exportStar(require("./types"), exports);
+__exportStar(require("./validators"), exports);

package/dist/types/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Types and interfaces for Genata data generation
+ */
+export type FieldType = "first_name" | "last_name" | "full_name" | "email" | "password" | "phone" | "address" | "city" | "country" | "zip" | "date" | "datetime" | "int" | "float" | "uuid" | "boolean" | "id_increment" | "number" | "zero_one" | "company" | "job_title" | "username" | "url" | "credit_card" | "ipv4" | "ipv6" | "color" | "paragraph" | "sentence";
+export interface GeneratorOptions {
+    seed?: number;
+    locale?: string;
+}
+export interface FieldDefinition {
+    name: string;
+    type: FieldType;
+    options?: Record<string, unknown>;
+}
+export interface BatchGeneratorOptions extends GeneratorOptions {
+    count?: number;
+}
+export interface GeneratorConfig {
+    minLength?: number;
+    maxLength?: number;
+    format?: string;
+    pattern?: string;
+    excludeSpecialChars?: boolean;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,WAAW,GACX,WAAW,GACX,OAAO,GACP,UAAU,GACV,OAAO,GACP,SAAS,GACT,MAAM,GACN,SAAS,GACT,KAAK,GACL,MAAM,GACN,UAAU,GACV,KAAK,GACL,OAAO,GACP,MAAM,GACN,SAAS,GACT,cAAc,GACd,QAAQ,GACR,UAAU,GACV,SAAS,GACT,WAAW,GACX,UAAU,GACV,KAAK,GACL,aAAa,GACb,MAAM,GACN,MAAM,GACN,OAAO,GACP,WAAW,GACX,UAAU,CAAC;AAEf,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B"}

package/dist/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Types and interfaces for Genata data generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/faker.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Faker wrapper with seeding support
+ */
+import { Faker } from "@faker-js/faker";
+import type { GeneratorOptions } from "../types";
+/**
+ * Initialize the global faker instance with optional seed
+ */
+export declare function initializeFaker(options?: GeneratorOptions): Faker;
+/**
+ * Get the current faker instance
+ */
+export declare function getFaker(options?: GeneratorOptions): Faker;
+/**
+ * Reset faker to a new random state
+ */
+export declare function resetFaker(): void;
+//# sourceMappingURL=faker.d.ts.map

package/dist/utils/faker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faker.d.ts","sourceRoot":"","sources":["../../src/utils/faker.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,EAAM,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIjD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,KAAK,CAejE;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,KAAK,CAE1D;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAEjC"}