refactor!: reorganize src folder (#909)

32 files changed, 8866 insertions, 0 deletions

diff --git a/src/modules/address/index.ts b/src/modules/address/index.ts
new file mode 100644
index 00000000..db82e01e
--- /dev/null
+++ b/src/modules/address/index.ts
@@ -0,0 +1,488 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate addresses and locations.
+ */
+export class Address {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Address.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generates random zip code from specified format. If format is not specified,
+   * the locale's zip format is used.
+   *
+   * @param format The optional format used to generate the the zip code.
+   * By default, a random format is used from the locale zip formats.
+   *
+   * @see faker.helpers.replaceSymbols()
+   *
+   * @example
+   * faker.address.zipCode() // '17839'
+   * faker.address.zipCode('####') // '6925'
+   *
+   */
+  zipCode(format?: string): string {
+    // if zip format is not specified, use the zip format defined for the locale
+    if (format == null) {
+      const localeFormat = this.faker.definitions.address.postcode;
+      if (typeof localeFormat === 'string') {
+        format = localeFormat;
+      } else {
+        format = this.faker.helpers.arrayElement(localeFormat);
+      }
+    }
+    return this.faker.helpers.replaceSymbols(format);
+  }
+
+  /**
+   * Generates random zip code from state abbreviation. If state abbreviation is
+   * not specified, a random zip code is generated according to the locale's zip format.
+   * Only works for locales with postcode_by_state definition. If a locale does not
+   * have a postcode_by_state definition, a random zip code is generated according
+   * to the locale's zip format.
+   *
+   * @param state The abbreviation of the state to generate the zip code for.
+   *
+   * @example
+   * fakerUS.address.zipCodeByState("AK") // '99595'
+   * fakerUS.address.zipCodeByState("??") // '47683-9880'
+   */
+  zipCodeByState(state: string): string {
+    const zipRange = this.faker.definitions.address.postcode_by_state?.[state];
+    if (zipRange) {
+      return String(this.faker.datatype.number(zipRange));
+    }
+    return this.zipCode();
+  }
+
+  /**
+   * Generates a random localized city name.
+   *
+   * @param format The format to use. Can be either the index of the format to use or
+   * any method provided by faker wrapped in `{{}}`, e.g. `{{name.firstName}}` in
+   * order to build the city name.
+   *
+   * If no format string is provided one of the following is randomly used:
+   *
+   * - `{{address.cityPrefix}} {{name.firstName}}{{address.citySuffix}}`
+   * - `{{address.cityPrefix}} {{name.firstName}}`
+   * - `{{name.firstName}}{{address.citySuffix}}`
+   * - `{{name.lastName}}{{address.citySuffix}}`
+   * - `{{address.cityName}}` when city name is available
+   *
+   * @example
+   * faker.address.city() // 'Gleasonbury'
+   * faker.address.city(2) // 'Jadenshire'
+   */
+  // TODO ST-DDT 2022-02-10: The string parameter doesn't work as expected.
+  city(format?: string | number): string {
+    const formats = [
+      '{{address.cityPrefix}} {{name.firstName}}{{address.citySuffix}}',
+      '{{address.cityPrefix}} {{name.firstName}}',
+      '{{name.firstName}}{{address.citySuffix}}',
+      '{{name.lastName}}{{address.citySuffix}}',
+    ];
+
+    if (!format && this.faker.definitions.address.city_name) {
+      formats.push('{{address.cityName}}');
+    }
+
+    if (typeof format !== 'number') {
+      format = this.faker.datatype.number(formats.length - 1);
+    }
+
+    return this.faker.fake(formats[format]);
+  }
+
+  /**
+   * Returns a random localized city prefix.
+   *
+   * @example
+   * faker.address.cityPrefix() // 'East'
+   */
+  cityPrefix(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.city_prefix
+    );
+  }
+
+  /**
+   * Returns a random localized city suffix.
+   *
+   * @example
+   * faker.address.citySuffix() // 'mouth'
+   */
+  citySuffix(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.city_suffix
+    );
+  }
+
+  /**
+   * Returns a random localized city name.
+   *
+   * @example
+   * faker.address.cityName() // 'San Rafael'
+   */
+  cityName(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.city_name
+    );
+  }
+
+  /**
+   * Generates a random building number.
+   *
+   * @example
+   * faker.address.buildingNumber() // '379'
+   */
+  buildingNumber(): string {
+    const format = this.faker.helpers.arrayElement(
+      this.faker.definitions.address.building_number
+    );
+
+    return this.faker.helpers.replaceSymbolWithNumber(format);
+  }
+
+  /**
+   * Generates a random localized street name.
+   *
+   * @example
+   * faker.address.streetName() // 'Kulas Roads'
+   */
+  streetName(): string {
+    let result: string;
+    let suffix = this.streetSuffix();
+    if (suffix !== '') {
+      suffix = ` ${suffix}`;
+    }
+
+    switch (this.faker.datatype.number(1)) {
+      case 0:
+        result = this.faker.name.lastName() + suffix;
+        break;
+      case 1:
+        result = this.faker.name.firstName() + suffix;
+        break;
+    }
+    return result;
+  }
+
+  /**
+   * Generates a random localized street address.
+   *
+   * @param useFullAddress When true this will generate a full address.
+   * Otherwise it will just generate a street address.
+   *
+   * @example
+   * faker.address.streetName() // '0917 O'Conner Estates'
+   * faker.address.streetAddress(true) // '3393 Ronny Way Apt. 742'
+   * faker.address.streetAddress(false) // '34830 Erdman Hollow'
+   */
+  streetAddress(useFullAddress: boolean = false): string {
+    const formats = this.faker.definitions.address.street_address;
+    const format = formats[useFullAddress ? 'full' : 'normal'];
+
+    return this.faker.fake(format);
+  }
+
+  /**
+   * Returns a random localized street suffix.
+   *
+   * @example
+   * faker.address.streetSuffix() // 'Streets'
+   */
+  streetSuffix(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.street_suffix
+    );
+  }
+
+  /**
+   * Returns a random localized street prefix.
+   *
+   * @example
+   * fakerGH.address.streetPrefix() // 'Boame'
+   */
+  streetPrefix(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.street_prefix
+    );
+  }
+
+  /**
+   * Generates a random localized secondary address. This refers to a specific location at a given address
+   * such as an apartment or room number.
+   *
+   * @example
+   * faker.address.secondaryAddress() // 'Apt. 861'
+   */
+  secondaryAddress(): string {
+    return this.faker.helpers.replaceSymbolWithNumber(
+      this.faker.helpers.arrayElement(
+        this.faker.definitions.address.secondary_address
+      )
+    );
+  }
+
+  /**
+   * Returns a random localized county.
+   *
+   * @example
+   * faker.address.county() // 'Cambridgeshire'
+   */
+  county(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.county
+    );
+  }
+
+  /**
+   * Returns a random country name.
+   *
+   * @example
+   * faker.address.country() // 'Greece'
+   */
+  country(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.country
+    );
+  }
+
+  /**
+   * Returns a random country code.
+   *
+   * @param alphaCode The code to return. Can be either `'alpha-2'` (2 letter code)
+   * or `'alpha-3'` (three letter code). Defaults to `'alpha-2'`.
+   *
+   * @example
+   * faker.address.countryCode() // 'SJ'
+   * faker.address.countryCode('alpha-2') // 'GA'
+   * faker.address.countryCode('alpha-3') // 'TJK'
+   */
+  countryCode(alphaCode: 'alpha-2' | 'alpha-3' = 'alpha-2'): string {
+    const key: keyof typeof this.faker.definitions.address =
+      alphaCode === 'alpha-3' ? 'country_code_alpha_3' : 'country_code';
+
+    return this.faker.helpers.arrayElement(this.faker.definitions.address[key]);
+  }
+
+  /**
+   * Returns a random localized state from this country.
+   *
+   * @example
+   * faker.address.state() // 'Georgia'
+   */
+  state(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.state
+    );
+  }
+
+  /**
+   * Returns a random localized state's abbreviated name from this country.
+   *
+   * @example
+   * faker.address.stateAbbr() // 'ND'
+   */
+  stateAbbr(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.state_abbr
+    );
+  }
+
+  /**
+   * Generates a random latitude.
+   *
+   * @param max The upper bound for the latitude to generate. Defaults to `90`.
+   * @param min The lower bound for the latitude to generate. Defaults to `-90`.
+   * @param precision The number of decimal points of precision for the latitude. Defaults to `4`.
+   *
+   * @example
+   * faker.address.latitude() // '-30.9501'
+   * faker.address.latitude(10, -10, 5) // '2.68452'
+   */
+  latitude(max: number = 90, min: number = -90, precision: number = 4): string {
+    return this.faker.datatype
+      .number({
+        min,
+        max,
+        precision: parseFloat(`${(0.0).toPrecision(precision)}1`),
+      })
+      .toFixed(precision);
+  }
+
+  /**
+   * Generates a random longitude.
+   *
+   * @param max The upper bound for the longitude to generate. Defaults to `180`.
+   * @param min The lower bound for the longitude to generate. Defaults to `-180`.
+   * @param precision The number of decimal points of precision for the longitude. Defaults to `4`.
+   *
+   * @example
+   * faker.address.longitude() // '-154.0226'
+   * faker.address.longitude(10, -10, 5) // '-4.03620'
+   */
+  longitude(
+    max: number = 180,
+    min: number = -180,
+    precision: number = 4
+  ): string {
+    return this.faker.datatype
+      .number({
+        max: max,
+        min: min,
+        precision: parseFloat(`${(0.0).toPrecision(precision)}1`),
+      })
+      .toFixed(precision);
+  }
+
+  /**
+   * Returns a random direction (cardinal and ordinal; northwest, east, etc).
+   *
+   * @param useAbbr If true this will return abbreviated directions (NW, E, etc).
+   * Otherwise this will return the long name. Defaults to `false`.
+   *
+   * @example
+   * faker.address.direction() // 'Northeast'
+   * faker.address.direction(false) // 'South'
+   * faker.address.direction(true) // 'NE'
+   */
+  direction(useAbbr: boolean = false): string {
+    if (!useAbbr) {
+      return this.faker.helpers.arrayElement(
+        this.faker.definitions.address.direction
+      );
+    }
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.direction_abbr
+    );
+  }
+
+  /**
+   * Returns a random cardinal direction (north, east, south, west).
+   *
+   * @param useAbbr If true this will return abbreviated directions (N, E, etc).
+   * Otherwise this will return the long name. Defaults to `false`.
+   *
+   * @example
+   * faker.address.cardinalDirection() // 'North'
+   * faker.address.cardinalDirection(false) // 'South'
+   * faker.address.cardinalDirection(true) // 'N'
+   */
+  cardinalDirection(useAbbr: boolean = false): string {
+    if (!useAbbr) {
+      return this.faker.helpers.arrayElement(
+        this.faker.definitions.address.direction.slice(0, 4)
+      );
+    }
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.direction_abbr.slice(0, 4)
+    );
+  }
+
+  /**
+   * Returns a random ordinal direction (northwest, southeast, etc).
+   *
+   * @param useAbbr If true this will return abbreviated directions (NW, SE, etc).
+   * Otherwise this will return the long name. Defaults to `false`.
+   *
+   * @example
+   * faker.address.ordinalDirection() // 'Northeast'
+   * faker.address.ordinalDirection(false) // 'Northwest'
+   * faker.address.ordinalDirection(true) // 'NE'
+   */
+  ordinalDirection(useAbbr: boolean = false): string {
+    if (!useAbbr) {
+      return this.faker.helpers.arrayElement(
+        this.faker.definitions.address.direction.slice(4, 8)
+      );
+    }
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.direction_abbr.slice(4, 8)
+    );
+  }
+
+  /**
+   * Generates a random GPS coordinate within the specified radius from the given coordinate.
+   *
+   * @param coordinate The original coordinate to get a new coordinate close to.
+   * If no coordinate is given, a random one will be chosen.
+   * @param radius The maximum distance from the given coordinate to the new coordinate. Defaults to `10`.
+   * @param isMetric If `true` assume the radius to be in kilometers. If `false` for miles. Defaults to `false`.
+   *
+   * @example
+   * faker.address.nearbyGPSCoordinate() // [ '33.8475', '-170.5953' ]
+   * faker.address.nearbyGPSCoordinate([33, -170]) // [ '33.0165', '-170.0636' ]
+   * faker.address.nearbyGPSCoordinate([33, -170], 1000, true) // [ '37.9163', '-179.2408' ]
+   */
+  // TODO ST-DDT 2022-02-10: Allow coordinate parameter to be [string, string].
+  nearbyGPSCoordinate(
+    coordinate?: [latitude: number, longitude: number],
+    radius: number = 10,
+    isMetric: boolean = false
+  ): [latitude: string, longitude: string] {
+    // If there is no coordinate, the best we can do is return a random GPS coordinate.
+    if (coordinate === undefined) {
+      return [this.latitude(), this.longitude()];
+    }
+
+    const angleRadians = this.faker.datatype.float({
+      min: 0,
+      max: 2 * Math.PI,
+      precision: 0.00001,
+    }); // in ° radians
+
+    const radiusMetric = isMetric ? radius : radius * 1.60934; // in km
+    const errorCorrection = 0.995; // avoid float issues
+    const distanceInKm =
+      this.faker.datatype.float({
+        min: 0,
+        max: radiusMetric,
+        precision: 0.001,
+      }) * errorCorrection; // in km
+
+    /**
+     * The distance in km per degree for earth.
+     */
+    // TODO @Shinigami92 2022-04-26: Provide an option property to provide custom circumferences.
+    const kmPerDegree = 40_000 / 360; // in km/°
+
+    const distanceInDegree = distanceInKm / kmPerDegree; // in °
+
+    const newCoordinate: [latitude: number, longitude: number] = [
+      coordinate[0] + Math.sin(angleRadians) * distanceInDegree,
+      coordinate[1] + Math.cos(angleRadians) * distanceInDegree,
+    ];
+
+    // Box latitude [-90°, 90°]
+    newCoordinate[0] = newCoordinate[0] % 180;
+    if (newCoordinate[0] < -90 || newCoordinate[0] > 90) {
+      newCoordinate[0] = Math.sign(newCoordinate[0]) * 180 - newCoordinate[0];
+      newCoordinate[1] += 180;
+    }
+    // Box longitude [-180°, 180°]
+    newCoordinate[1] = (((newCoordinate[1] % 360) + 540) % 360) - 180;
+
+    return [newCoordinate[0].toFixed(4), newCoordinate[1].toFixed(4)];
+  }
+
+  /**
+   * Returns a random time zone.
+   *
+   * @example
+   * faker.address.timeZone() // 'Pacific/Guam'
+   */
+  timeZone(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.address.time_zone
+    );
+  }
+}
diff --git a/src/modules/animal/index.ts b/src/modules/animal/index.ts
new file mode 100644
index 00000000..416fe533
--- /dev/null
+++ b/src/modules/animal/index.ts
@@ -0,0 +1,164 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate animal related entries.
+ */
+export class Animal {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Animal.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a random dog breed.
+   *
+   * @example
+   * faker.animal.dog() // 'Irish Water Spaniel'
+   */
+  dog(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.dog);
+  }
+
+  /**
+   * Returns a random cat breed.
+   *
+   * @example
+   * faker.animal.cat() // 'Singapura'
+   */
+  cat(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.cat);
+  }
+
+  /**
+   * Returns a random snake species.
+   *
+   * @example
+   * faker.animal.snake() // 'Eyelash viper'
+   */
+  snake(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.snake);
+  }
+
+  /**
+   * Returns a random bear species.
+   *
+   * @example
+   * faker.animal.bear() // 'Asian black bear'
+   */
+  bear(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.bear);
+  }
+
+  /**
+   * Returns a random lion species.
+   *
+   * @example
+   * faker.animal.lion() // 'Northeast Congo Lion'
+   */
+  lion(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.lion);
+  }
+
+  /**
+   * Returns a random cetacean species.
+   *
+   * @example
+   * faker.animal.cetacean() // 'Spinner Dolphin'
+   */
+  cetacean(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.animal.cetacean
+    );
+  }
+
+  /**
+   * Returns a random horse breed.
+   *
+   * @example
+   * faker.animal.horse() // 'Swedish Warmblood'
+   */
+  horse(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.horse);
+  }
+
+  /**
+   * Returns a random bird species.
+   *
+   * @example
+   * faker.animal.bird() // 'Buller's Shearwater'
+   */
+  bird(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.bird);
+  }
+
+  /**
+   * Returns a random cow species.
+   *
+   * @example
+   * faker.animal.cow() // 'Brava'
+   */
+  cow(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.cow);
+  }
+
+  /**
+   * Returns a random fish species.
+   *
+   * @example
+   * faker.animal.fish() // 'Mandarin fish'
+   */
+  fish(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.fish);
+  }
+
+  /**
+   * Returns a random crocodilian species.
+   *
+   * @example
+   * faker.animal.crocodilia() // 'Philippine Crocodile'
+   */
+  crocodilia(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.animal.crocodilia
+    );
+  }
+
+  /**
+   * Returns a random insect species.
+   *
+   * @example
+   * faker.animal.insect() // 'Pyramid ant'
+   */
+  insect(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.animal.insect
+    );
+  }
+
+  /**
+   * Returns a random rabbit species.
+   *
+   * @example
+   * faker.animal.rabbit() // 'Florida White'
+   */
+  rabbit(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.animal.rabbit
+    );
+  }
+
+  /**
+   * Returns a random animal type.
+   *
+   * @example
+   * faker.animal.type() // 'crocodilia'
+   */
+  type(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.animal.type);
+  }
+}
diff --git a/src/modules/commerce/index.ts b/src/modules/commerce/index.ts
new file mode 100644
index 00000000..71ce96d6
--- /dev/null
+++ b/src/modules/commerce/index.ts
@@ -0,0 +1,133 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate commerce and product related entries.
+ */
+export class Commerce {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Commerce.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a human readable color name.
+   *
+   * @example
+   * faker.commerce.color() // 'red'
+   */
+  color(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.commerce.color
+    );
+  }
+
+  /**
+   * Returns a department inside a shop.
+   *
+   * @example
+   * faker.commerce.department() // 'Garden'
+   */
+  department(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.commerce.department
+    );
+  }
+
+  /**
+   * Generates a random descriptive product name.
+   *
+   * @example
+   * faker.commerce.productName() // 'Incredible Soft Gloves'
+   */
+  productName(): string {
+    return `${this.productAdjective()} ${this.productMaterial()} ${this.product()}`;
+  }
+
+  /**
+   * Generates a price between min and max (inclusive).
+   *
+   * @param min The minimum price. Defaults to `1`.
+   * @param max The maximum price. Defaults to `1000`.
+   * @param dec The number of decimal places. Defaults to `2`.
+   * @param symbol The currency value to use. Defaults to `''`.
+   *
+   * @example
+   * faker.commerce.price() // 828.00
+   * faker.commerce.price(100) // 904.00
+   * faker.commerce.price(100, 200) // 154.00
+   * faker.commerce.price(100, 200, 0) // 133
+   * faker.commerce.price(100, 200, 0, '$') // $114
+   */
+  price(
+    min: number = 1,
+    max: number = 1000,
+    dec: number = 2,
+    symbol: string = ''
+  ): string {
+    if (min < 0 || max < 0) {
+      return `${symbol}${0.0}`;
+    }
+
+    const randValue = this.faker.datatype.number({ max: max, min: min });
+
+    return (
+      symbol +
+      (Math.round(randValue * Math.pow(10, dec)) / Math.pow(10, dec)).toFixed(
+        dec
+      )
+    );
+  }
+
+  /**
+   * Returns an adjective describing a product.
+   *
+   * @example
+   * faker.commerce.productAdjective() // 'Handcrafted'
+   */
+  productAdjective(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.commerce.product_name.adjective
+    );
+  }
+
+  /**
+   * Returns a material of a product.
+   *
+   * @example
+   * faker.commerce.productMaterial() // 'Rubber'
+   */
+  productMaterial(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.commerce.product_name.material
+    );
+  }
+
+  /**
+   * Returns a short product name.
+   *
+   * @example
+   * faker.commerce.product() // 'Computer'
+   */
+  product(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.commerce.product_name.product
+    );
+  }
+
+  /**
+   * Returns a product description.
+   *
+   * @example
+   * faker.commerce.productDescription() // 'Andy shoes are designed to keeping...'
+   */
+  productDescription(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.commerce.product_description
+    );
+  }
+}
diff --git a/src/modules/company/index.ts b/src/modules/company/index.ts
new file mode 100644
index 00000000..fb5f2e66
--- /dev/null
+++ b/src/modules/company/index.ts
@@ -0,0 +1,153 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate company related entries.
+ */
+export class Company {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Company.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns an array with possible company name suffixes.
+   *
+   * @example
+   * faker.company.suffixes() // [ 'Inc', 'and Sons', 'LLC', 'Group' ]
+   */
+  suffixes(): string[] {
+    // Don't want the source array exposed to modification, so return a copy
+    return this.faker.definitions.company.suffix.slice(0);
+  }
+
+  /**
+   * Generates a random company name.
+   *
+   * @param format The optional format index used to select a format.
+   *
+   * @example
+   * faker.company.companyName() // 'Zieme, Hauck and McClure'
+   */
+  companyName(format?: number): string {
+    const formats = [
+      '{{name.lastName}} {{company.companySuffix}}',
+      '{{name.lastName}} - {{name.lastName}}',
+      '{{name.lastName}}, {{name.lastName}} and {{name.lastName}}',
+    ];
+
+    if (typeof format !== 'number') {
+      format = this.faker.datatype.number(formats.length - 1);
+    }
+
+    return this.faker.fake(formats[format]);
+  }
+
+  /**
+   * Returns a random company suffix.
+   *
+   * @example
+   * faker.company.companySuffix() // 'and Sons'
+   */
+  companySuffix(): string {
+    return this.faker.helpers.arrayElement(this.suffixes());
+  }
+
+  /**
+   * Generates a random business catch phrase.
+   *
+   * @example
+   * faker.company.catchPhrase() // 'Upgradable systematic flexibility'
+   */
+  catchPhrase(): string {
+    return this.faker.fake(
+      '{{company.catchPhraseAdjective}} {{company.catchPhraseDescriptor}} {{company.catchPhraseNoun}}'
+    );
+  }
+
+  /**
+   * Generates a random company bs phrase.
+   *
+   * @example
+   * faker.company.bs() // 'cultivate synergistic e-markets'
+   */
+  bs(): string {
+    return this.faker.fake(
+      '{{company.bsBuzz}} {{company.bsAdjective}} {{company.bsNoun}}'
+    );
+  }
+
+  /**
+   * Returns a random catch phrase adjective.
+   *
+   * @example
+   * faker.company.catchPhraseAdjective() // 'Multi-tiered'
+   */
+  catchPhraseAdjective(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.company.adjective
+    );
+  }
+
+  /**
+   * Returns a random catch phrase descriptor.
+   *
+   * @example
+   * faker.company.catchPhraseDescriptor() // 'composite'
+   */
+  catchPhraseDescriptor(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.company.descriptor
+    );
+  }
+
+  /**
+   * Returns a random catch phrase noun.
+   *
+   * @example
+   * faker.company.catchPhraseNoun() // 'leverage'
+   */
+  catchPhraseNoun(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.company.noun);
+  }
+
+  /**
+   * Returns a random company bs adjective.
+   *
+   * @example
+   * faker.company.bsAdjective() // 'one-to-one'
+   */
+  bsAdjective(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.company.bs_adjective
+    );
+  }
+
+  /**
+   * Returns a random company bs buzz word.
+   *
+   * @example
+   * faker.company.bsBuzz() // 'empower'
+   */
+  bsBuzz(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.company.bs_verb
+    );
+  }
+
+  /**
+   * Returns a random company bs noun.
+   *
+   * @example
+   * faker.company.bsNoun() // 'paradigms'
+   */
+  bsNoun(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.company.bs_noun
+    );
+  }
+}
diff --git a/src/modules/database/index.ts b/src/modules/database/index.ts
new file mode 100644
index 00000000..073d3f8a
--- /dev/null
+++ b/src/modules/database/index.ts
@@ -0,0 +1,75 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate database related entries.
+ */
+export class Database {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Database.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a random database column name.
+   *
+   * @example
+   * faker.database.column() // 'createdAt'
+   */
+  column(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.database.column
+    );
+  }
+
+  /**
+   * Returns a random database column type.
+   *
+   * @example
+   * faker.database.type() // 'timestamp'
+   */
+  type(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.database.type
+    );
+  }
+
+  /**
+   * Returns a random database collation.
+   *
+   * @example
+   * faker.database.collation() // 'utf8_unicode_ci'
+   */
+  collation(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.database.collation
+    );
+  }
+
+  /**
+   * Returns a random database engine.
+   *
+   * @example
+   * faker.database.engine() // 'ARCHIVE'
+   */
+  engine(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.database.engine
+    );
+  }
+
+  /**
+   * Returns a MongoDB [ObjectId](https://docs.mongodb.com/manual/reference/method/ObjectId/) string.
+   *
+   * @example
+   * faker.database.mongodbObjectId() // 'e175cac316a79afdd0ad3afb'
+   */
+  mongodbObjectId(): string {
+    // strip the "0x" from the hexadecimal output
+    return this.faker.datatype.hexadecimal(24).replace('0x', '').toLowerCase();
+  }
+}
diff --git a/src/modules/datatype/index.ts b/src/modules/datatype/index.ts
new file mode 100644
index 00000000..653d4d3f
--- /dev/null
+++ b/src/modules/datatype/index.ts
@@ -0,0 +1,305 @@
+import type { Faker } from '../..';
+import { FakerError } from '../../errors/faker-error';
+import { deprecated } from '../../internal/deprecated';
+
+/**
+ * Module to generate various primitive values and data types.
+ */
+export class Datatype {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Datatype.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a single random number between zero and the given max value or the given range with the specified precision.
+   * The bounds are inclusive.
+   *
+   * @param options Maximum value or options object.
+   * @param options.min Lower bound for generated number. Defaults to `0`.
+   * @param options.max Upper bound for generated number. Defaults to `min + 99999`.
+   * @param options.precision Precision of the generated number. Defaults to `1`.
+   *
+   * @throws When options define `max < min`.
+   *
+   * @example
+   * faker.datatype.number() // 55422
+   * faker.datatype.number(100) // 52
+   * faker.datatype.number({ min: 1000000 }) // 431433
+   * faker.datatype.number({ max: 100 }) // 42
+   * faker.datatype.number({ precision: 0.01 }) // 64246.18
+   * faker.datatype.number({ min: 10, max: 100, precision: 0.01 }) // 36.94
+   */
+  number(
+    options: number | { min?: number; max?: number; precision?: number } = 99999
+  ): number {
+    if (typeof options === 'number') {
+      options = { max: options };
+    }
+
+    const { min = 0, precision = 1 } = options;
+    const max = options.max ?? min + 99999;
+
+    if (max === min) {
+      return min;
+    }
+
+    if (max < min) {
+      throw new FakerError(`Max ${max} should be larger then min ${min}.`);
+    }
+
+    const randomNumber = Math.floor(
+      this.faker.mersenne.rand(max / precision + 1, min / precision)
+    );
+
+    // Workaround problem in float point arithmetics for e.g. 6681493 / 0.01
+    return randomNumber / (1 / precision);
+  }
+
+  /**
+   * Returns a single random floating-point number for the given precision or range and precision.
+   *
+   * @param options Precision or options object.
+   * @param options.min Lower bound for generated number. Defaults to `0`.
+   * @param options.max Upper bound for generated number. Defaults to `99999`.
+   * @param options.precision Precision of the generated number. Defaults to `0.01`.
+   *
+   * @example
+   * faker.datatype.float() // 51696.36
+   * faker.datatype.float(0.1) // 52023.2
+   * faker.datatype.float({ min: 1000000 }) // 212859.76
+   * faker.datatype.float({ max: 100 }) // 28.11
+   * faker.datatype.float({ precision: 0.1 }) // 84055.3
+   * faker.datatype.float({ min: 10, max: 100, precision: 0.001 }) // 57.315
+   */
+  float(
+    options?: number | { min?: number; max?: number; precision?: number }
+  ): number {
+    if (typeof options === 'number') {
+      options = {
+        precision: options,
+      };
+    }
+    options = options || {};
+    const opts: { precision?: number } = {};
+    for (const p in options) {
+      opts[p] = options[p];
+    }
+    if (opts.precision == null) {
+      opts.precision = 0.01;
+    }
+    return this.number(opts);
+  }
+
+  /**
+   * Returns a Date object using a random number of milliseconds since
+   * the [Unix Epoch](https://en.wikipedia.org/wiki/Unix_time) (1 January 1970 UTC).
+   *
+   * @param options Max number of milliseconds since unix epoch or options object.
+   * @param options.min Lower bound for milliseconds since base date.
+   *    When not provided or smaller than `-8640000000000000`, `1990-01-01` is considered
+   *    as minimum generated date. Defaults to `631152000000`.
+   * @param options.max Upper bound for milliseconds since base date.
+   *    When not provided or larger than `8640000000000000`, `2100-01-01` is considered
+   *    as maximum generated date. Defaults to `4102444800000`.
+   *
+   * @example
+   * faker.datatype.datetime() // '2089-04-17T18:03:24.956Z'
+   * faker.datatype.datetime(1893456000000) // '2022-03-28T07:00:56.876Z'
+   * faker.datatype.datetime({ min: 1577836800000, max: 1893456000000 }) // '2021-09-12T07:13:00.255Z'
+   */
+  datetime(options: number | { min?: number; max?: number } = {}): Date {
+    const minMax = 8640000000000000;
+
+    let min = typeof options === 'number' ? undefined : options.min;
+    let max = typeof options === 'number' ? options : options.max;
+
+    if (min == null || min < minMax * -1) {
+      min = Date.UTC(1990, 0);
+    }
+
+    if (max == null || max > minMax) {
+      max = Date.UTC(2100, 0);
+    }
+
+    return new Date(this.number({ min, max }));
+  }
+
+  /**
+   * Returns a string containing UTF-16 chars between 33 and 125 (`!` to `}`).
+   *
+   * @param length Length of the generated string. Max length is `2^20`. Defaults to `10`.
+   *
+   * @example
+   * faker.datatype.string() // 'Zo!.:*e>wR'
+   * faker.datatype.string(5) // '6Bye8'
+   */
+  string(length = 10): string {
+    const maxLength = Math.pow(2, 20);
+    if (length >= maxLength) {
+      length = maxLength;
+    }
+
+    const charCodeOption = {
+      min: 33,
+      max: 125,
+    };
+
+    let returnString = '';
+
+    for (let i = 0; i < length; i++) {
+      returnString += String.fromCharCode(this.number(charCodeOption));
+    }
+
+    return returnString;
+  }
+
+  /**
+   * Returns a UUID v4 ([Universally Unique Identifier](https://en.wikipedia.org/wiki/Universally_unique_identifier)).
+   *
+   * @example
+   * faker.datatype.uuid() // '4136cd0b-d90b-4af7-b485-5d1ded8db252'
+   */
+  uuid(): string {
+    const RFC4122_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+    const replacePlaceholders = (placeholder) => {
+      const random = this.number({ min: 0, max: 15 });
+      const value = placeholder === 'x' ? random : (random & 0x3) | 0x8;
+      return value.toString(16);
+    };
+    return RFC4122_TEMPLATE.replace(/[xy]/g, replacePlaceholders);
+  }
+
+  /**
+   * Returns the boolean value true or false.
+   *
+   * @example
+   * faker.datatype.boolean() // false
+   */
+  boolean(): boolean {
+    return !!this.number(1);
+  }
+
+  /**
+   * Returns a [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) number.
+   *
+   * @param length Length of the generated number. Defaults to `1`.
+   *
+   * @see faker.datatype.hexadecimal()
+   *
+   * @example
+   * faker.datatype.hexaDecimal() // '0xb'
+   * faker.datatype.hexaDecimal(10) // '0xaE13F044fb'
+   *
+   * @deprecated
+   */
+  hexaDecimal(length = 1): string {
+    deprecated({
+      deprecated: 'faker.datatype.hexaDecimal()',
+      proposed: 'faker.datatype.hexadecimal()',
+      since: 'v6.1.2',
+      until: 'v7.0.0',
+    });
+
+    return this.hexadecimal(length);
+  }
+
+  /**
+   * Returns a [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) number.
+   *
+   * @param length Length of the generated number. Defaults to `1`.
+   *
+   * @example
+   * faker.datatype.hexadecimal() // '0xb'
+   * faker.datatype.hexadecimal(10) // '0xaE13F044fb'
+   */
+  hexadecimal(length = 1): string {
+    let wholeString = '';
+
+    for (let i = 0; i < length; i++) {
+      wholeString += this.faker.helpers.arrayElement([
+        '0',
+        '1',
+        '2',
+        '3',
+        '4',
+        '5',
+        '6',
+        '7',
+        '8',
+        '9',
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+      ]);
+    }
+
+    return `0x${wholeString}`;
+  }
+
+  /**
+   * Returns a string representing JSON object with 7 pre-defined properties.
+   *
+   * @example
+   * faker.datatype.json() // `{"foo":"mxz.v8ISij","bar":29154,"bike":8658,"a":"GxTlw$nuC:","b":40693,"name":"%'<FTou{7X","prop":"X(bd4iT>77"}`
+   */
+  json(): string {
+    const properties = ['foo', 'bar', 'bike', 'a', 'b', 'name', 'prop'];
+    const returnObject: Record<string, string | number> = {};
+
+    properties.forEach((prop) => {
+      returnObject[prop] = this.boolean() ? this.string() : this.number();
+    });
+
+    return JSON.stringify(returnObject);
+  }
+
+  /**
+   * Returns an array with random strings and numbers.
+   *
+   * @param length Size of the returned array. Defaults to `10`.
+   *
+   * @example
+   * faker.datatype.array() // [ 94099, 85352, 'Hz%T.C\\l;8', '|#gmtw3otS', '2>:rJ|3$&d', 56864, 'Ss2-p0RXSI', 51084, 2039, 'mNEU[.r0Vf' ]
+   * faker.datatype.array(3) // [ 61845, 'SK7H$W3:d*', 'm[%7N8*GVK' ]
+   */
+  array(length = 10): Array<string | number> {
+    return Array.from<string | number>({ length }).map(() =>
+      this.boolean() ? this.string() : this.number()
+    );
+  }
+
+  /**
+   * Returns a [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#bigint_type) number.
+   *
+   * @param value When provided, this method simply converts it to `BigInt` type.
+   *
+   * @example
+   * faker.datatype.bigInt() // 8507209999914928n
+   * faker.datatype.bigInt('156') // 156n
+   * faker.datatype.bigInt(30) // 30n
+   * faker.datatype.bigInt(3000n) // 3000n
+   * faker.datatype.bigInt(true) // 1n
+   */
+  bigInt(value?: string | number | bigint | boolean): bigint {
+    if (value === undefined) {
+      value = Math.floor(this.number() * 99999999999) + 10000000000;
+    }
+
+    return BigInt(value);
+  }
+}
diff --git a/src/modules/date/index.ts b/src/modules/date/index.ts
new file mode 100644
index 00000000..09f608f0
--- /dev/null
+++ b/src/modules/date/index.ts
@@ -0,0 +1,256 @@
+import type { Faker } from '../..';
+import type { DateEntryDefinition } from '../../definitions';
+
+/**
+ * Converts date passed as a string, number or Date to a Date object.
+ * If nothing or a non parseable value is passed, takes current date.
+ *
+ * @param date Date
+ */
+function toDate(date?: string | Date | number): Date {
+  date = new Date(date);
+  if (isNaN(date.valueOf())) {
+    date = new Date();
+  }
+
+  return date;
+}
+
+/**
+ * Module to generate dates.
+ */
+export class _Date {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(_Date.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generates a random date in the past.
+   *
+   * @param years The range of years the date may be in the past. Defaults to `1`.
+   * @param refDate The date to use as reference point for the newly generated date. Defaults to now.
+   *
+   * @see faker.date.recent()
+   *
+   * @example
+   * faker.date.past() // '2021-12-03T05:40:44.408Z'
+   * faker.date.past(10) // '2017-10-25T21:34:19.488Z'
+   * faker.date.past(10, '2020-01-01T00:00:00.000Z') // '2017-08-18T02:59:12.350Z'
+   */
+  past(years?: number, refDate?: string | Date | number): Date {
+    const date = toDate(refDate);
+    const range = {
+      min: 1000,
+      max: (years || 1) * 365 * 24 * 3600 * 1000,
+    };
+
+    let past = date.getTime();
+    past -= this.faker.datatype.number(range); // some time from now to N years ago, in milliseconds
+    date.setTime(past);
+
+    return date;
+  }
+
+  /**
+   * Generates a random date in the future.
+   *
+   * @param years The range of years the date may be in the future. Defaults to `1`.
+   * @param refDate The date to use as reference point for the newly generated date. Defaults to now.
+   *
+   * @see faker.date.soon()
+   *
+   * @example
+   * faker.date.future() // '2022-11-19T05:52:49.100Z'
+   * faker.date.future(10) // '2030-11-23T09:38:28.710Z'
+   * faker.date.future(10, '2020-01-01T00:00:00.000Z') // '2020-12-13T22:45:10.252Z'
+   */
+  future(years?: number, refDate?: string | Date | number): Date {
+    const date = toDate(refDate);
+    const range = {
+      min: 1000,
+      max: (years || 1) * 365 * 24 * 3600 * 1000,
+    };
+
+    let future = date.getTime();
+    future += this.faker.datatype.number(range); // some time from now to N years later, in milliseconds
+    date.setTime(future);
+
+    return date;
+  }
+
+  /**
+   * Generates a random date between the given boundaries.
+   *
+   * @param from The early date boundary.
+   * @param to The late date boundary.
+   *
+   * @example
+   * faker.date.between('2020-01-01T00:00:00.000Z', '2030-01-01T00:00:00.000Z') // '2026-05-16T02:22:53.002Z'
+   */
+  between(from: string | Date | number, to: string | Date | number): Date {
+    const fromMs = toDate(from).getTime();
+    const toMs = toDate(to).getTime();
+    const dateOffset = this.faker.datatype.number(toMs - fromMs);
+
+    return new Date(fromMs + dateOffset);
+  }
+
+  /**
+   * Generates n random dates between the given boundaries.
+   *
+   * @param from The early date boundary.
+   * @param to The late date boundary.
+   * @param num The number of dates to generate. Defaults to `3`.
+   *
+   * @example
+   * faker.date.betweens('2020-01-01T00:00:00.000Z', '2030-01-01T00:00:00.000Z')
+   * // [
+   * //   2022-07-02T06:00:00.000Z,
+   * //   2024-12-31T12:00:00.000Z,
+   * //   2027-07-02T18:00:00.000Z
+   * // ]
+   * faker.date.betweens('2020-01-01T00:00:00.000Z', '2030-01-01T00:00:00.000Z', 2)
+   * // [ 2023-05-02T16:00:00.000Z, 2026-09-01T08:00:00.000Z ]
+   */
+  betweens(
+    from: string | Date | number,
+    to: string | Date | number,
+    num: number = 3
+  ): Date[] {
+    const dates: Date[] = [];
+
+    while (dates.length < num) {
+      dates.push(this.between(from, to));
+    }
+
+    return dates.sort((a, b) => a.getTime() - b.getTime());
+  }
+
+  /**
+   * Generates a random date in the recent past.
+   *
+   * @param days The range of days the date may be in the past. Defaults to `1`.
+   * @param refDate The date to use as reference point for the newly generated date. Defaults to now.
+   *
+   * @see faker.date.past()
+   *
+   * @example
+   * faker.date.recent() // '2022-02-04T02:09:35.077Z'
+   * faker.date.recent(10) // '2022-01-29T06:12:12.829Z'
+   * faker.date.recent(10, '2020-01-01T00:00:00.000Z') // '2019-12-27T18:11:19.117Z'
+   */
+  recent(days?: number, refDate?: string | Date | number): Date {
+    const date = toDate(refDate);
+    const range = {
+      min: 1000,
+      max: (days || 1) * 24 * 3600 * 1000,
+    };
+
+    let future = date.getTime();
+    future -= this.faker.datatype.number(range); // some time from now to N days ago, in milliseconds
+    date.setTime(future);
+
+    return date;
+  }
+
+  /**
+   * Generates a random date in the near future.
+   *
+   * @param days The range of days the date may be in the future. Defaults to `1`.
+   * @param refDate The date to use as reference point for the newly generated date. Defaults to now.
+   *
+   * @see faker.date.future()
+   *
+   * @example
+   * faker.date.soon() // '2022-02-05T09:55:39.216Z'
+   * faker.date.soon(10) // '2022-02-11T05:14:39.138Z'
+   * faker.date.soon(10, '2020-01-01T00:00:00.000Z') // '2020-01-01T02:40:44.990Z'
+   */
+  soon(days?: number, refDate?: string | Date | number): Date {
+    const date = toDate(refDate);
+    const range = {
+      min: 1000,
+      max: (days || 1) * 24 * 3600 * 1000,
+    };
+
+    let future = date.getTime();
+    future += this.faker.datatype.number(range); // some time from now to N days later, in milliseconds
+    date.setTime(future);
+
+    return date;
+  }
+
+  /**
+   * Returns a random name of a month.
+   *
+   * @param options The optional options to use.
+   * @param options.abbr Whether to return an abbreviation. Defaults to `false`.
+   * @param options.context Whether to return the name of a month in a context. Defaults to `false`.
+   *
+   * @example
+   * faker.date.month() // 'October'
+   * faker.date.month({ abbr: true }) // 'Feb'
+   * faker.date.month({ context: true }) // 'June'
+   * faker.date.month({ abbr: true, context: true }) // 'Sep'
+   */
+  month(options?: { abbr?: boolean; context?: boolean }): string {
+    const abbr = options?.abbr ?? false;
+    const context = options?.context ?? false;
+
+    const source = this.faker.definitions.date.month;
+    let type: keyof DateEntryDefinition;
+    if (abbr) {
+      if (context && source['abbr_context'] != null) {
+        type = 'abbr_context';
+      } else {
+        type = 'abbr';
+      }
+    } else if (context && source['wide_context'] != null) {
+      type = 'wide_context';
+    } else {
+      type = 'wide';
+    }
+
+    return this.faker.helpers.arrayElement(source[type]);
+  }
+
+  /**
+   * Returns a random day of the week.
+   *
+   * @param options The optional options to use.
+   * @param options.abbr Whether to return an abbreviation. Defaults to `false`.
+   * @param options.context Whether to return the day of the week in a context. Defaults to `false`.
+   *
+   * @example
+   * faker.date.weekday() // 'Monday'
+   * faker.date.weekday({ abbr: true }) // 'Thu'
+   * faker.date.weekday({ context: true }) // 'Thursday'
+   * faker.date.weekday({ abbr: true, context: true }) // 'Fri'
+   */
+  weekday(options?: { abbr?: boolean; context?: boolean }): string {
+    const abbr = options?.abbr ?? false;
+    const context = options?.context ?? false;
+
+    const source = this.faker.definitions.date.weekday;
+    let type: keyof DateEntryDefinition;
+    if (abbr) {
+      if (context && source['abbr_context'] != null) {
+        type = 'abbr_context';
+      } else {
+        type = 'abbr';
+      }
+    } else if (context && source['wide_context'] != null) {
+      type = 'wide_context';
+    } else {
+      type = 'wide';
+    }
+
+    return this.faker.helpers.arrayElement(source[type]);
+  }
+}
diff --git a/src/modules/fake/index.ts b/src/modules/fake/index.ts
new file mode 100644
index 00000000..a9f2a22a
--- /dev/null
+++ b/src/modules/fake/index.ts
@@ -0,0 +1,134 @@
+import type { Faker } from '../..';
+import { FakerError } from '../../errors/faker-error';
+
+/**
+ * Generator method for combining faker methods based on string input.
+ */
+export class Fake {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Fake.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generator for combining faker methods based on a static string input.
+   *
+   * Note: We recommend using string template literals instead of `fake()`,
+   * which are faster and strongly typed (if you are using TypeScript),
+   * e.g. ``const address = `${faker.address.zipCode()} ${faker.address.city()}`;``
+   *
+   * This method is useful if you have to build a random string from a static, non-executable source
+   * (e.g. string coming from a user, stored in a database or a file).
+   *
+   * It checks the given string for placeholders and replaces them by calling faker methods:
+   *
+   * ```js
+   * const hello = faker.fake('Hi, my name is {{name.firstName}} {{name.lastName}}!')
+   * ```
+   *
+   * This would use the `faker.name.firstName()` and `faker.name.lastName()` method to resolve the placeholders respectively.
+   *
+   * It is also possible to provide parameters. At first, they will be parsed as json,
+   * and if that isn't possible, we will fall back to string:
+   *
+   * ```js
+   * const message = faker.fake(`You can call me at {{phone.phoneNumber(+!# !## #### #####!)}}.')
+   * ```
+   *
+   * Currently it is not possible to set more than a single parameter.
+   *
+   * It is also NOT possible to use any non-faker methods or plain javascript in such templates.
+   *
+   * @param str The template string that will get interpolated. Must not be empty.
+   *
+   * @see faker.helpers.mustache() to use custom functions for resolution.
+   *
+   * @example
+   * faker.fake('{{name.lastName}}') // 'Barrows'
+   * faker.fake('{{name.lastName}}, {{name.firstName}} {{name.suffix}}') // 'Durgan, Noe MD'
+   * faker.fake('This is static test.') // 'This is static test.'
+   * faker.fake('Good Morning {{name.firstName}}!') // 'Good Morning Estelle!'
+   * faker.fake('You can call me at {{phone.phoneNumber(!## ### #####!)}}.') // 'You can call me at 202 555 973722.'
+   * faker.fake('I flipped the coin an got: {{helpers.arrayElement(["heads", "tails"])}}') // 'I flipped the coin an got: tails'
+   */
+  fake(str: string): string {
+    // if incoming str parameter is not provided, return error message
+    if (typeof str !== 'string' || str.length === 0) {
+      throw new FakerError('string parameter is required!');
+    }
+
+    // find first matching {{ and }}
+    const start = str.search(/{{[a-z]/);
+    const end = str.indexOf('}}', start);
+
+    // if no {{ and }} is found, we are done
+    if (start === -1 || end === -1) {
+      return str;
+    }
+
+    // extract method name from between the {{ }} that we found
+    // for example: {{name.firstName}}
+    const token = str.substring(start + 2, end + 2);
+    let method = token.replace('}}', '').replace('{{', '');
+
+    // extract method parameters
+    const regExp = /\(([^)]+)\)/;
+    const matches = regExp.exec(method);
+    let parameters = '';
+    if (matches) {
+      method = method.replace(regExp, '');
+      parameters = matches[1];
+    }
+
+    // split the method into module and function
+    const parts = method.split('.');
+
+    if (this.faker[parts[0]] == null) {
+      throw new FakerError(`Invalid module: ${parts[0]}`);
+    }
+
+    if (this.faker[parts[0]][parts[1]] == null) {
+      throw new FakerError(`Invalid method: ${parts[0]}.${parts[1]}`);
+    }
+
+    // assign the function from the module.function namespace
+    let fn: (args?: unknown) => string = this.faker[parts[0]][parts[1]];
+    fn = fn.bind(this);
+
+    // If parameters are populated here, they are always going to be of string type
+    // since we might actually be dealing with an object or array,
+    // we always attempt to the parse the incoming parameters into JSON
+    let params: unknown;
+    // Note: we experience a small performance hit here due to JSON.parse try / catch
+    // If anyone actually needs to optimize this specific code path, please open a support issue on github
+    try {
+      params = JSON.parse(parameters);
+    } catch (err) {
+      // since JSON.parse threw an error, assume parameters was actually a string
+      params = parameters;
+    }
+
+    let result: string;
+    if (typeof params === 'string' && params.length === 0) {
+      result = String(fn());
+    } else {
+      result = String(fn(params));
+    }
+
+    // Replace the found tag with the returned fake value
+    // We cannot use string.replace here because the result might contain evaluated characters
+    const res = str.substring(0, start) + result + str.substring(end + 2);
+
+    if (res === '') {
+      return '';
+    }
+
+    // return the response recursively until we are done finding all tags
+    return this.fake(res);
+  }
+}
diff --git a/src/modules/finance/iban.ts b/src/modules/finance/iban.ts
new file mode 100644
index 00000000..9b4780c5
--- /dev/null
+++ b/src/modules/finance/iban.ts
@@ -0,0 +1,1414 @@
+interface Iban {
+  alpha: string[];
+  formats: Array<{
+    bban: Array<{ type: string; count: number }>;
+    country: string;
+    format?: string;
+    total?: number;
+  }>;
+  iso3166: string[];
+  mod97: (digitStr: string) => number;
+  pattern10: string[];
+  pattern100: string[];
+  toDigitString: (str: string) => string;
+}
+
+const iban: Iban = {
+  alpha: [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+  ],
+  formats: [
+    {
+      country: 'AL',
+      total: 28,
+      bban: [
+        {
+          type: 'n',
+          count: 8,
+        },
+        {
+          type: 'c',
+          count: 16,
+        },
+      ],
+      format: 'ALkk bbbs sssx cccc cccc cccc cccc',
+    },
+    {
+      country: 'AD',
+      total: 24,
+      bban: [
+        {
+          type: 'n',
+          count: 8,
+        },
+        {
+          type: 'c',
+          count: 12,
+        },
+      ],
+      format: 'ADkk bbbb ssss cccc cccc cccc',
+    },
+    {
+      country: 'AT',
+      total: 20,
+      bban: [
+        {
+          type: 'n',
+          count: 5,
+        },
+        {
+          type: 'n',
+          count: 11,
+        },
+      ],
+      format: 'ATkk bbbb bccc cccc cccc',
+    },
+    {
+      // Azerbaijan
+      // https://transferwise.com/fr/iban/azerbaijan
+      // Length 28
+      // BBAN 2c,16n
+      // GEkk bbbb cccc cccc cccc cccc cccc
+      // b = National bank code (alpha)
+      // c = Account number
+      // example IBAN AZ21 NABZ 0000 0000 1370 1000 1944
+      country: 'AZ',
+      total: 28,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 20,
+        },
+      ],
+      format: 'AZkk bbbb cccc cccc cccc cccc cccc',
+    },
+    {
+      country: 'BH',
+      total: 22,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 14,
+        },
+      ],
+      format: 'BHkk bbbb cccc cccc cccc cc',
+    },
+    {
+      country: 'BE',
+      total: 16,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'n',
+          count: 9,
+        },
+      ],
+      format: 'BEkk bbbc cccc ccxx',
+    },
+    {
+      country: 'BA',
+      total: 20,
+      bban: [
+        {
+          type: 'n',
+          count: 6,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'BAkk bbbs sscc cccc ccxx',
+    },
+    {
+      country: 'BR',
+      total: 29,
+      bban: [
+        {
+          type: 'n',
+          count: 13,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'a',
+          count: 1,
+        },
+        {
+          type: 'c',
+          count: 1,
+        },
+      ],
+      format: 'BRkk bbbb bbbb ssss sccc cccc ccct n',
+    },
+    {
+      country: 'BG',
+      total: 22,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 6,
+        },
+        {
+          type: 'c',
+          count: 8,
+        },
+      ],
+      format: 'BGkk bbbb ssss ddcc cccc cc',
+    },
+    {
+      country: 'CR',
+      total: 22,
+      bban: [
+        {
+          type: 'n',
+          count: 1,
+        },
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'n',
+          count: 14,
+        },
+      ],
+      format: 'CRkk xbbb cccc cccc cccc cc',
+    },
+    {
+      country: 'HR',
+      total: 21,
+      bban: [
+        {
+          type: 'n',
+          count: 7,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'HRkk bbbb bbbc cccc cccc c',
+    },
+    {
+      country: 'CY',
+      total: 28,
+      bban: [
+        {
+          type: 'n',
+          count: 8,
+        },
+        {
+          type: 'c',
+          count: 16,
+        },
+      ],
+      format: 'CYkk bbbs ssss cccc cccc cccc cccc',
+    },
+    {
+      country: 'CZ',
+      total: 24,
+      bban: [
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'CZkk bbbb ssss sscc cccc cccc',
+    },
+    {
+      country: 'DK',
+      total: 18,
+      bban: [
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'DKkk bbbb cccc cccc cc',
+    },
+    {
+      country: 'DO',
+      total: 28,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 20,
+        },
+      ],
+      format: 'DOkk bbbb cccc cccc cccc cccc cccc',
+    },
+    {
+      country: 'TL',
+      total: 23,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'TLkk bbbc cccc cccc cccc cxx',
+    },
+    {
+      country: 'EE',
+      total: 20,
+      bban: [
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 12,
+        },
+      ],
+      format: 'EEkk bbss cccc cccc cccx',
+    },
+    {
+      country: 'FO',
+      total: 18,
+      bban: [
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'FOkk bbbb cccc cccc cx',
+    },
+    {
+      country: 'FI',
+      total: 18,
+      bban: [
+        {
+          type: 'n',
+          count: 6,
+        },
+        {
+          type: 'n',
+          count: 8,
+        },
+      ],
+      format: 'FIkk bbbb bbcc cccc cx',
+    },
+    {
+      country: 'FR',
+      total: 27,
+      bban: [
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'c',
+          count: 11,
+        },
+        {
+          type: 'n',
+          count: 2,
+        },
+      ],
+      format: 'FRkk bbbb bggg ggcc cccc cccc cxx',
+    },
+    {
+      country: 'GE',
+      total: 22,
+      bban: [
+        {
+          type: 'a',
+          count: 2,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'GEkk bbcc cccc cccc cccc cc',
+    },
+    {
+      country: 'DE',
+      total: 22,
+      bban: [
+        {
+          type: 'n',
+          count: 8,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'DEkk bbbb bbbb cccc cccc cc',
+    },
+    {
+      country: 'GI',
+      total: 23,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 15,
+        },
+      ],
+      format: 'GIkk bbbb cccc cccc cccc ccc',
+    },
+    {
+      country: 'GR',
+      total: 27,
+      bban: [
+        {
+          type: 'n',
+          count: 7,
+        },
+        {
+          type: 'c',
+          count: 16,
+        },
+      ],
+      format: 'GRkk bbbs sssc cccc cccc cccc ccc',
+    },
+    {
+      country: 'GL',
+      total: 18,
+      bban: [
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'GLkk bbbb cccc cccc cc',
+    },
+    {
+      country: 'GT',
+      total: 28,
+      bban: [
+        {
+          type: 'c',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 16,
+        },
+      ],
+      format: 'GTkk bbbb mmtt cccc cccc cccc cccc',
+    },
+    {
+      country: 'HU',
+      total: 28,
+      bban: [
+        {
+          type: 'n',
+          count: 8,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'HUkk bbbs sssk cccc cccc cccc cccx',
+    },
+    {
+      country: 'IS',
+      total: 26,
+      bban: [
+        {
+          type: 'n',
+          count: 6,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'ISkk bbbb sscc cccc iiii iiii ii',
+    },
+    {
+      country: 'IE',
+      total: 22,
+      bban: [
+        {
+          type: 'c',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 6,
+        },
+        {
+          type: 'n',
+          count: 8,
+        },
+      ],
+      format: 'IEkk aaaa bbbb bbcc cccc cc',
+    },
+    {
+      country: 'IL',
+      total: 23,
+      bban: [
+        {
+          type: 'n',
+          count: 6,
+        },
+        {
+          type: 'n',
+          count: 13,
+        },
+      ],
+      format: 'ILkk bbbn nncc cccc cccc ccc',
+    },
+    {
+      country: 'IT',
+      total: 27,
+      bban: [
+        {
+          type: 'a',
+          count: 1,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'c',
+          count: 12,
+        },
+      ],
+      format: 'ITkk xaaa aabb bbbc cccc cccc ccc',
+    },
+    {
+      country: 'JO',
+      total: 30,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 18,
+        },
+      ],
+      format: 'JOkk bbbb nnnn cccc cccc cccc cccc cc',
+    },
+    {
+      country: 'KZ',
+      total: 20,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'c',
+          count: 13,
+        },
+      ],
+      format: 'KZkk bbbc cccc cccc cccc',
+    },
+    {
+      country: 'XK',
+      total: 20,
+      bban: [
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 12,
+        },
+      ],
+      format: 'XKkk bbbb cccc cccc cccc',
+    },
+    {
+      country: 'KW',
+      total: 30,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 22,
+        },
+      ],
+      format: 'KWkk bbbb cccc cccc cccc cccc cccc cc',
+    },
+    {
+      country: 'LV',
+      total: 21,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 13,
+        },
+      ],
+      format: 'LVkk bbbb cccc cccc cccc c',
+    },
+    {
+      country: 'LB',
+      total: 28,
+      bban: [
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 20,
+        },
+      ],
+      format: 'LBkk bbbb cccc cccc cccc cccc cccc',
+    },
+    {
+      country: 'LI',
+      total: 21,
+      bban: [
+        {
+          type: 'n',
+          count: 5,
+        },
+        {
+          type: 'c',
+          count: 12,
+        },
+      ],
+      format: 'LIkk bbbb bccc cccc cccc c',
+    },
+    {
+      country: 'LT',
+      total: 20,
+      bban: [
+        {
+          type: 'n',
+          count: 5,
+        },
+        {
+          type: 'n',
+          count: 11,
+        },
+      ],
+      format: 'LTkk bbbb bccc cccc cccc',
+    },
+    {
+      country: 'LU',
+      total: 20,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'c',
+          count: 13,
+        },
+      ],
+      format: 'LUkk bbbc cccc cccc cccc',
+    },
+    {
+      country: 'MK',
+      total: 19,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'c',
+          count: 10,
+        },
+        {
+          type: 'n',
+          count: 2,
+        },
+      ],
+      format: 'MKkk bbbc cccc cccc cxx',
+    },
+    {
+      country: 'MT',
+      total: 31,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 5,
+        },
+        {
+          type: 'c',
+          count: 18,
+        },
+      ],
+      format: 'MTkk bbbb ssss sccc cccc cccc cccc ccc',
+    },
+    {
+      country: 'MR',
+      total: 27,
+      bban: [
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'n',
+          count: 13,
+        },
+      ],
+      format: 'MRkk bbbb bsss sscc cccc cccc cxx',
+    },
+    {
+      country: 'MU',
+      total: 30,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 15,
+        },
+        {
+          type: 'a',
+          count: 3,
+        },
+      ],
+      format: 'MUkk bbbb bbss cccc cccc cccc 000d dd',
+    },
+    {
+      country: 'MC',
+      total: 27,
+      bban: [
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'c',
+          count: 11,
+        },
+        {
+          type: 'n',
+          count: 2,
+        },
+      ],
+      format: 'MCkk bbbb bsss sscc cccc cccc cxx',
+    },
+    {
+      country: 'MD',
+      total: 24,
+      bban: [
+        {
+          type: 'c',
+          count: 2,
+        },
+        {
+          type: 'c',
+          count: 18,
+        },
+      ],
+      format: 'MDkk bbcc cccc cccc cccc cccc',
+    },
+    {
+      country: 'ME',
+      total: 22,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'n',
+          count: 15,
+        },
+      ],
+      format: 'MEkk bbbc cccc cccc cccc xx',
+    },
+    {
+      country: 'NL',
+      total: 18,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'NLkk bbbb cccc cccc cc',
+    },
+    {
+      country: 'NO',
+      total: 15,
+      bban: [
+        {
+          type: 'n',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 7,
+        },
+      ],
+      format: 'NOkk bbbb cccc ccx',
+    },
+    {
+      country: 'PK',
+      total: 24,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'PKkk bbbb cccc cccc cccc cccc',
+    },
+    {
+      country: 'PS',
+      total: 29,
+      bban: [
+        {
+          type: 'c',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 9,
+        },
+        {
+          type: 'n',
+          count: 12,
+        },
+      ],
+      format: 'PSkk bbbb xxxx xxxx xccc cccc cccc c',
+    },
+    {
+      country: 'PL',
+      total: 28,
+      bban: [
+        {
+          type: 'n',
+          count: 8,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'PLkk bbbs sssx cccc cccc cccc cccc',
+    },
+    {
+      country: 'PT',
+      total: 25,
+      bban: [
+        {
+          type: 'n',
+          count: 8,
+        },
+        {
+          type: 'n',
+          count: 13,
+        },
+      ],
+      format: 'PTkk bbbb ssss cccc cccc cccx x',
+    },
+    {
+      country: 'QA',
+      total: 29,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 21,
+        },
+      ],
+      format: 'QAkk bbbb cccc cccc cccc cccc cccc c',
+    },
+    {
+      country: 'RO',
+      total: 24,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'c',
+          count: 16,
+        },
+      ],
+      format: 'ROkk bbbb cccc cccc cccc cccc',
+    },
+    {
+      country: 'SM',
+      total: 27,
+      bban: [
+        {
+          type: 'a',
+          count: 1,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'c',
+          count: 12,
+        },
+      ],
+      format: 'SMkk xaaa aabb bbbc cccc cccc ccc',
+    },
+    {
+      country: 'SA',
+      total: 24,
+      bban: [
+        {
+          type: 'n',
+          count: 2,
+        },
+        {
+          type: 'c',
+          count: 18,
+        },
+      ],
+      format: 'SAkk bbcc cccc cccc cccc cccc',
+    },
+    {
+      country: 'RS',
+      total: 22,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'n',
+          count: 15,
+        },
+      ],
+      format: 'RSkk bbbc cccc cccc cccc xx',
+    },
+    {
+      country: 'SK',
+      total: 24,
+      bban: [
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'SKkk bbbb ssss sscc cccc cccc',
+    },
+    {
+      country: 'SI',
+      total: 19,
+      bban: [
+        {
+          type: 'n',
+          count: 5,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'SIkk bbss sccc cccc cxx',
+    },
+    {
+      country: 'ES',
+      total: 24,
+      bban: [
+        {
+          type: 'n',
+          count: 10,
+        },
+        {
+          type: 'n',
+          count: 10,
+        },
+      ],
+      format: 'ESkk bbbb gggg xxcc cccc cccc',
+    },
+    {
+      country: 'SE',
+      total: 24,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'n',
+          count: 17,
+        },
+      ],
+      format: 'SEkk bbbc cccc cccc cccc cccc',
+    },
+    {
+      country: 'CH',
+      total: 21,
+      bban: [
+        {
+          type: 'n',
+          count: 5,
+        },
+        {
+          type: 'c',
+          count: 12,
+        },
+      ],
+      format: 'CHkk bbbb bccc cccc cccc c',
+    },
+    {
+      country: 'TN',
+      total: 24,
+      bban: [
+        {
+          type: 'n',
+          count: 5,
+        },
+        {
+          type: 'n',
+          count: 15,
+        },
+      ],
+      format: 'TNkk bbss sccc cccc cccc cccc',
+    },
+    {
+      country: 'TR',
+      total: 26,
+      bban: [
+        {
+          type: 'n',
+          count: 5,
+        },
+        {
+          type: 'n',
+          count: 1,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'TRkk bbbb bxcc cccc cccc cccc cc',
+    },
+    {
+      country: 'AE',
+      total: 23,
+      bban: [
+        {
+          type: 'n',
+          count: 3,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'AEkk bbbc cccc cccc cccc ccc',
+    },
+    {
+      country: 'GB',
+      total: 22,
+      bban: [
+        {
+          type: 'a',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 6,
+        },
+        {
+          type: 'n',
+          count: 8,
+        },
+      ],
+      format: 'GBkk bbbb ssss sscc cccc cc',
+    },
+    {
+      country: 'VG',
+      total: 24,
+      bban: [
+        {
+          type: 'c',
+          count: 4,
+        },
+        {
+          type: 'n',
+          count: 16,
+        },
+      ],
+      format: 'VGkk bbbb cccc cccc cccc cccc',
+    },
+  ],
+  iso3166: [
+    'AD',
+    'AE',
+    'AF',
+    'AG',
+    'AI',
+    'AL',
+    'AM',
+    'AO',
+    'AQ',
+    'AR',
+    'AS',
+    'AT',
+    'AU',
+    'AW',
+    'AX',
+    'AZ',
+    'BA',
+    'BB',
+    'BD',
+    'BE',
+    'BF',
+    'BG',
+    'BH',
+    'BI',
+    'BJ',
+    'BL',
+    'BM',
+    'BN',
+    'BO',
+    'BQ',
+    'BR',
+    'BS',
+    'BT',
+    'BV',
+    'BW',
+    'BY',
+    'BZ',
+    'CA',
+    'CC',
+    'CD',
+    'CF',
+    'CG',
+    'CH',
+    'CI',
+    'CK',
+    'CL',
+    'CM',
+    'CN',
+    'CO',
+    'CR',
+    'CU',
+    'CV',
+    'CW',
+    'CX',
+    'CY',
+    'CZ',
+    'DE',
+    'DJ',
+    'DK',
+    'DM',
+    'DO',
+    'DZ',
+    'EC',
+    'EE',
+    'EG',
+    'EH',
+    'ER',
+    'ES',
+    'ET',
+    'FI',
+    'FJ',
+    'FK',
+    'FM',
+    'FO',
+    'FR',
+    'GA',
+    'GB',
+    'GD',
+    'GE',
+    'GF',
+    'GG',
+    'GH',
+    'GI',
+    'GL',
+    'GM',
+    'GN',
+    'GP',
+    'GQ',
+    'GR',
+    'GS',
+    'GT',
+    'GU',
+    'GW',
+    'GY',
+    'HK',
+    'HM',
+    'HN',
+    'HR',
+    'HT',
+    'HU',
+    'ID',
+    'IE',
+    'IL',
+    'IM',
+    'IN',
+    'IO',
+    'IQ',
+    'IR',
+    'IS',
+    'IT',
+    'JE',
+    'JM',
+    'JO',
+    'JP',
+    'KE',
+    'KG',
+    'KH',
+    'KI',
+    'KM',
+    'KN',
+    'KP',
+    'KR',
+    'KW',
+    'KY',
+    'KZ',
+    'LA',
+    'LB',
+    'LC',
+    'LI',
+    'LK',
+    'LR',
+    'LS',
+    'LT',
+    'LU',
+    'LV',
+    'LY',
+    'MA',
+    'MC',
+    'MD',
+    'ME',
+    'MF',
+    'MG',
+    'MH',
+    'MK',
+    'ML',
+    'MM',
+    'MN',
+    'MO',
+    'MP',
+    'MQ',
+    'MR',
+    'MS',
+    'MT',
+    'MU',
+    'MV',
+    'MW',
+    'MX',
+    'MY',
+    'MZ',
+    'NA',
+    'NC',
+    'NE',
+    'NF',
+    'NG',
+    'NI',
+    'NL',
+    'NO',
+    'NP',
+    'NR',
+    'NU',
+    'NZ',
+    'OM',
+    'PA',
+    'PE',
+    'PF',
+    'PG',
+    'PH',
+    'PK',
+    'PL',
+    'PM',
+    'PN',
+    'PR',
+    'PS',
+    'PT',
+    'PW',
+    'PY',
+    'QA',
+    'RE',
+    'RO',
+    'RS',
+    'RU',
+    'RW',
+    'SA',
+    'SB',
+    'SC',
+    'SD',
+    'SE',
+    'SG',
+    'SH',
+    'SI',
+    'SJ',
+    'SK',
+    'SL',
+    'SM',
+    'SN',
+    'SO',
+    'SR',
+    'SS',
+    'ST',
+    'SV',
+    'SX',
+    'SY',
+    'SZ',
+    'TC',
+    'TD',
+    'TF',
+    'TG',
+    'TH',
+    'TJ',
+    'TK',
+    'TL',
+    'TM',
+    'TN',
+    'TO',
+    'TR',
+    'TT',
+    'TV',
+    'TW',
+    'TZ',
+    'UA',
+    'UG',
+    'UM',
+    'US',
+    'UY',
+    'UZ',
+    'VA',
+    'VC',
+    'VE',
+    'VG',
+    'VI',
+    'VN',
+    'VU',
+    'WF',
+    'WS',
+    'XK',
+    'YE',
+    'YT',
+    'ZA',
+    'ZM',
+    'ZW',
+  ],
+  mod97: (digitStr) => {
+    let m = 0;
+    for (let i = 0; i < digitStr.length; i++) {
+      m = (m * 10 + +digitStr[i]) % 97;
+    }
+    return m;
+  },
+  pattern10: ['01', '02', '03', '04', '05', '06', '07', '08', '09'],
+  pattern100: ['001', '002', '003', '004', '005', '006', '007', '008', '009'],
+  toDigitString: (str) =>
+    str.replace(/[A-Z]/gi, (match) =>
+      String(match.toUpperCase().charCodeAt(0) - 55)
+    ),
+};
+
+export default iban;
diff --git a/src/modules/finance/index.ts b/src/modules/finance/index.ts
new file mode 100644
index 00000000..a74dceba
--- /dev/null
+++ b/src/modules/finance/index.ts
@@ -0,0 +1,436 @@
+import type { Faker } from '../..';
+import { FakerError } from '../../errors/faker-error';
+import iban from './iban';
+
+/**
+ * Module to generate finance related entries.
+ */
+export class Finance {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Finance.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generates a random account number.
+   *
+   * @param length The length of the account number. Defaults to `8`.
+   *
+   * @example
+   * faker.finance.account() // 92842238
+   * faker.finance.account(5) // 32564
+   */
+  account(length?: number): string {
+    length = length || 8;
+    let template = '';
+
+    for (let i = 0; i < length; i++) {
+      template += '#';
+    }
+    length = null;
+    return this.faker.helpers.replaceSymbolWithNumber(template);
+  }
+
+  /**
+   * Generates a random account name.
+   *
+   * @example
+   * faker.finance.accountName() // 'Personal Loan Account'
+   */
+  accountName(): string {
+    return [
+      this.faker.helpers.arrayElement(
+        this.faker.definitions.finance.account_type
+      ),
+      'Account',
+    ].join(' ');
+  }
+
+  /**
+   * Generates a random routing number.
+   *
+   * @example
+   * faker.finance.routingNumber() // '522814402'
+   */
+  routingNumber(): string {
+    const routingNumber =
+      this.faker.helpers.replaceSymbolWithNumber('########');
+
+    // Modules 10 straight summation.
+    let sum = 0;
+
+    for (let i = 0; i < routingNumber.length; i += 3) {
+      sum += Number(routingNumber[i]) * 3;
+      sum += Number(routingNumber[i + 1]) * 7;
+      sum += Number(routingNumber[i + 2]) || 0;
+    }
+
+    return `${routingNumber}${Math.ceil(sum / 10) * 10 - sum}`;
+  }
+
+  /**
+   * Generates a random masked number.
+   *
+   * @param length The length of the unmasked number. Defaults to `4`.
+   * @param parens Whether to use surrounding parenthesis. Defaults to `true`.
+   * @param ellipsis Whether to prefix the numbers with an ellipsis. Defaults to `true`.
+   *
+   * @example
+   * faker.finance.mask() // '(...9711)'
+   * faker.finance.mask(3) // '(...342)'
+   * faker.finance.mask(3, false) // '...236'
+   * faker.finance.mask(3, false, false) // '298'
+   */
+  mask(length?: number, parens?: boolean, ellipsis?: boolean): string {
+    // set defaults
+    length = length || 4;
+    parens = parens == null ? true : parens;
+    ellipsis = ellipsis == null ? true : ellipsis;
+
+    // create a template for length
+    let template = '';
+
+    for (let i = 0; i < length; i++) {
+      template = `${template}#`;
+    }
+
+    //prefix with ellipsis
+    template = ellipsis ? ['...', template].join('') : template;
+
+    template = parens ? ['(', template, ')'].join('') : template;
+
+    //generate random numbers
+    template = this.faker.helpers.replaceSymbolWithNumber(template);
+
+    return template;
+  }
+
+  /**
+   * Generates a random amount between the given bounds (inclusive).
+   *
+   * @param min The lower bound for the amount. Defaults to `0`.
+   * @param max The upper bound for the amount. Defaults to `1000`.
+   * @param dec The number of decimal places for the amount. Defaults to `2`.
+   * @param symbol The symbol used to prefix the amount. Defaults to `''`.
+   * @param autoFormat If true this method will use `Number.toLocaleString()`. Otherwise it will use `Number.toFixed()`.
+   *
+   * @example
+   * faker.finance.amount() // '617.87'
+   * faker.finance.amount(5, 10) // '5.53'
+   * faker.finance.amount(5, 10, 0) // '8'
+   * faker.finance.amount(5, 10, 2, '$') // '$5.85'
+   * faker.finance.amount(5, 10, 5, '', true) // '9,75067'
+   */
+  amount(
+    min: number = 0,
+    max: number = 1000,
+    dec: number = 2,
+    symbol: string = '',
+    autoFormat?: boolean
+  ): string {
+    const randValue = this.faker.datatype.number({
+      max,
+      min,
+      precision: Math.pow(10, -dec),
+    });
+
+    let formattedString: string;
+    if (autoFormat) {
+      formattedString = randValue.toLocaleString(undefined, {
+        minimumFractionDigits: dec,
+      });
+    } else {
+      formattedString = randValue.toFixed(dec);
+    }
+
+    return symbol + formattedString;
+  }
+
+  /**
+   * Returns a random transaction type.
+   *
+   * @example
+   * faker.finance.transactionType() // 'payment'
+   */
+  transactionType(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.finance.transaction_type
+    );
+  }
+
+  /**
+   * Returns a random currency code.
+   * (The short text/abbreviation for the currency (e.g. `US Dollar` -> `USD`))
+   *
+   * @example
+   * faker.finance.currencyCode() // 'USD'
+   */
+  currencyCode(): string {
+    return this.faker.helpers.objectValue(
+      this.faker.definitions.finance.currency
+    )['code'];
+  }
+
+  /**
+   * Returns a random currency name.
+   *
+   * @example
+   * faker.finance.currencyName() // 'US Dollar'
+   */
+  currencyName(): string {
+    return this.faker.helpers.objectKey(
+      this.faker.definitions.finance.currency
+    ) as string;
+  }
+
+  /**
+   * Returns a random currency symbol.
+   *
+   * @example
+   * faker.finance.currencySymbol() // '$'
+   */
+  currencySymbol(): string {
+    let symbol: string;
+    while (!symbol) {
+      symbol = this.faker.helpers.objectValue(
+        this.faker.definitions.finance.currency
+      )['symbol'];
+    }
+    return symbol;
+  }
+
+  /**
+   * Generates a random bitcoin address.
+   *
+   * @example
+   * faker.finance.bitcoinAddress() // '3ySdvCkTLVy7gKD4j6JfSaf5d'
+   */
+  bitcoinAddress(): string {
+    const addressLength = this.faker.datatype.number({ min: 25, max: 34 });
+
+    let address = this.faker.helpers.arrayElement(['1', '3']);
+
+    for (let i = 0; i < addressLength - 1; i++)
+      address += this.faker.helpers.arrayElement(
+        '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'.split('')
+      );
+
+    return address;
+  }
+
+  /**
+   * Generates a random litecoin address.
+   *
+   * @example
+   * faker.finance.litecoinAddress() // 'MoQaSTGWBRXkWfyxKbNKuPrAWGELzcW'
+   */
+  litecoinAddress(): string {
+    const addressLength = this.faker.datatype.number({ min: 26, max: 33 });
+
+    let address = this.faker.helpers.arrayElement(['L', 'M', '3']);
+
+    for (let i = 0; i < addressLength - 1; i++)
+      address += this.faker.helpers.arrayElement(
+        '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'.split('')
+      );
+
+    return address;
+  }
+
+  /**
+   * Generates a random credit card number.
+   *
+   * @param issuer The name of the issuer (case insensitive) or the format used to generate one.
+   *
+   * @example
+   * faker.finance.creditCardNumber() // '4427163488668'
+   * faker.finance.creditCardNumber('visa') // '4882664999003'
+   * faker.finance.creditCardNumber('63[7-9]#-####-####-###L') // '6375-3265-4676-6644'
+   */
+  creditCardNumber(issuer = ''): string {
+    let format: string;
+    const localeFormat = this.faker.definitions.finance.credit_card;
+    const normalizedIssuer = issuer.toLowerCase();
+    if (normalizedIssuer in localeFormat) {
+      format = this.faker.helpers.arrayElement(localeFormat[normalizedIssuer]);
+    } else if (issuer.match(/#/)) {
+      // The user chose an optional scheme
+      format = issuer;
+    } else {
+      // Choose a random issuer
+      // Credit cards are in an object structure
+      const formats = this.faker.helpers.objectValue(localeFormat); // There could be multiple formats
+      format = this.faker.helpers.arrayElement(formats);
+    }
+    format = format.replace(/\//g, '');
+    return this.faker.helpers.replaceCreditCardSymbols(format);
+  }
+
+  /**
+   * Generates a random credit card CVV.
+   *
+   * @example
+   * faker.finance.creditCardCVV() // '506'
+   */
+  creditCardCVV(): string {
+    let cvv = '';
+    for (let i = 0; i < 3; i++) {
+      cvv += this.faker.datatype.number({ max: 9 }).toString();
+    }
+    return cvv;
+  }
+
+  /**
+   * Returns a random credit card issuer.
+   *
+   * @example
+   * faker.finance.creditCardIssuer() // 'discover'
+   */
+  creditCardIssuer(): string {
+    return this.faker.helpers.objectKey(
+      this.faker.definitions.finance.credit_card
+    ) as string;
+  }
+
+  /**
+   * Generates a random PIN number.
+   *
+   * @param length The length of the PIN to generate. Defaults to `4`.
+   * @throws Will throw an error if length is less than 1.
+   *
+   * @example
+   * faker.finance.pin() // '5067'
+   * faker.finance.pin(6) // '213789'
+   */
+  pin(length: number = 4): string {
+    if (length < 1) {
+      throw new FakerError('minimum length is 1');
+    }
+    return Array.from({ length }, () => this.faker.datatype.number(9)).join('');
+  }
+
+  /**
+   * Generates a random ethereum Address.
+   *
+   * @example
+   * faker.finance.ethereumAddress() // '0xf03dfeecbafc5147241cc4c4ca20b3c9dfd04c4a'
+   */
+  ethereumAddress(): string {
+    const address = this.faker.datatype.hexadecimal(40).toLowerCase();
+    return address;
+  }
+
+  /**
+   * Generates a random iban.
+   *
+   * @param formatted Return a formatted version of the generated IBAN. Defaults to `false`.
+   * @param countryCode The country code from which you want to generate an IBAN, if none is provided a random country will be used.
+   * @throws Will throw an error if the passed country code is not supported.
+   *
+   * @example
+   * faker.finance.iban() // 'TR736918640040966092800056'
+   * faker.finance.iban(true) // 'FR20 8008 2330 8984 74S3 Z620 224'
+   * faker.finance.iban(true, 'DE') // 'DE84 1022 7075 0900 1170 01'
+   */
+  iban(formatted: boolean = false, countryCode?: string): string {
+    const ibanFormat = countryCode
+      ? iban.formats.find((f) => f.country === countryCode)
+      : this.faker.helpers.arrayElement(iban.formats);
+
+    if (!ibanFormat) {
+      throw new FakerError(`Country code ${countryCode} not supported.`);
+    }
+
+    let s = '';
+    let count = 0;
+    for (const bban of ibanFormat.bban) {
+      let c = bban.count;
+      count += bban.count;
+      while (c > 0) {
+        if (bban.type === 'a') {
+          s += this.faker.helpers.arrayElement(iban.alpha);
+        } else if (bban.type === 'c') {
+          if (this.faker.datatype.number(100) < 80) {
+            s += this.faker.datatype.number(9);
+          } else {
+            s += this.faker.helpers.arrayElement(iban.alpha);
+          }
+        } else {
+          if (c >= 3 && this.faker.datatype.number(100) < 30) {
+            if (this.faker.datatype.boolean()) {
+              s += this.faker.helpers.arrayElement(iban.pattern100);
+              c -= 2;
+            } else {
+              s += this.faker.helpers.arrayElement(iban.pattern10);
+              c--;
+            }
+          } else {
+            s += this.faker.datatype.number(9);
+          }
+        }
+        c--;
+      }
+      s = s.substring(0, count);
+    }
+    let checksum: string | number =
+      98 - iban.mod97(iban.toDigitString(`${s}${ibanFormat.country}00`));
+
+    if (checksum < 10) {
+      checksum = `0${checksum}`;
+    }
+
+    const result = `${ibanFormat.country}${checksum}${s}`;
+
+    return formatted ? result.match(/.{1,4}/g).join(' ') : result;
+  }
+
+  /**
+   * Generates a random bic.
+   *
+   * @example
+   * faker.finance.bic() // 'WYAUPGX1432'
+   */
+  bic(): string {
+    const vowels = ['A', 'E', 'I', 'O', 'U'];
+    const prob = this.faker.datatype.number(100);
+
+    return [
+      this.faker.helpers.replaceSymbols('???'),
+      this.faker.helpers.arrayElement(vowels),
+      this.faker.helpers.arrayElement(iban.iso3166),
+      this.faker.helpers.replaceSymbols('?'),
+      '1',
+      prob < 10
+        ? this.faker.helpers.replaceSymbols(
+            `?${this.faker.helpers.arrayElement(vowels)}?`
+          )
+        : prob < 40
+        ? this.faker.helpers.replaceSymbols('###')
+        : '',
+    ].join('');
+  }
+
+  /**
+   * Generates a random transaction description.
+   *
+   * @example
+   * faker.finance.transactionDescription()
+   * // 'invoice transaction at Kilback - Durgan using card ending with ***(...4316) for UAH 783.82 in account ***16168663'
+   */
+  transactionDescription(): string {
+    const transaction = this.faker.helpers.createTransaction();
+    const account = transaction.account;
+    const amount = transaction.amount;
+    const transactionType = transaction.type;
+    const company = transaction.business;
+    const card = this.mask();
+    const currency = this.currencyCode();
+
+    return `${transactionType} transaction at ${company} using card ending with ***${card} for ${currency} ${amount} in account ***${account}`;
+  }
+}
diff --git a/src/modules/git/index.ts b/src/modules/git/index.ts
new file mode 100644
index 00000000..e86f6648
--- /dev/null
+++ b/src/modules/git/index.ts
@@ -0,0 +1,134 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate git related entries.
+ */
+export class Git {
+  private hexChars = [
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+  ];
+
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Git.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generates a random branch name.
+   *
+   * @example
+   * faker.git.branch() // 'feed-parse'
+   */
+  branch(): string {
+    const noun = this.faker.hacker.noun().replace(' ', '-');
+    const verb = this.faker.hacker.verb().replace(' ', '-');
+    return `${noun}-${verb}`;
+  }
+
+  /**
+   * Generates a random commit entry.
+   *
+   * @param options Options for the commit entry.
+   * @param options.merge Set to `true` to generate a merge message line.
+   * @param options.eol Choose the end of line character to use. Defaults to 'CRLF'.
+   * 'LF' = '\n',
+   * 'CRLF' = '\r\n'
+   *
+   * @example
+   * faker.git.commitEntry()
+   * // commit fe8c38a965d13d9794eb36918cb24cebe49a45c2
+   * // Author: Mable Harvey <[email protected]>
+   * // Date: Sat Feb 05 2022 15:09:18 GMT+0100 (Mitteleuropäische Normalzeit)
+   * //
+   * //     copy primary system
+   */
+  commitEntry(
+    options: {
+      merge?: boolean;
+      eol?: 'LF' | 'CRLF';
+    } = {}
+  ): string {
+    const lines = [`commit ${this.faker.git.commitSha()}`];
+
+    if (options.merge || this.faker.datatype.number({ min: 0, max: 4 }) === 0) {
+      lines.push(`Merge: ${this.shortSha()} ${this.shortSha()}`);
+    }
+
+    lines.push(
+      `Author: ${this.faker.name.firstName()} ${this.faker.name.lastName()} <${this.faker.internet.email()}>`,
+      `Date: ${this.faker.date.recent().toString()}`,
+      '',
+      `\xa0\xa0\xa0\xa0${this.commitMessage()}`,
+      // to end with a eol char
+      ''
+    );
+
+    const eolOption = options.eol ?? 'CRLF';
+    const eolChar = eolOption === 'CRLF' ? '\r\n' : '\n';
+    const entry = lines.join(eolChar);
+
+    return entry;
+  }
+
+  /**
+   * Generates a random commit message.
+   *
+   * @example
+   * faker.git.commitMessage() // 'reboot cross-platform driver'
+   */
+  commitMessage(): string {
+    return `${this.faker.hacker.verb()} ${this.faker.hacker.adjective()} ${this.faker.hacker.noun()}`;
+  }
+
+  /**
+   * Generates a random commit sha (full).
+   *
+   * @example
+   * faker.git.commitSha() // '2c6e3880fd94ddb7ef72d34e683cdc0c47bec6e6'
+   */
+  commitSha(): string {
+    let commit = '';
+
+    for (let i = 0; i < 40; i++) {
+      commit += this.faker.helpers.arrayElement(this.hexChars);
+    }
+
+    return commit;
+  }
+
+  /**
+   * Generates a random commit sha (short).
+   *
+   * @example
+   * faker.git.shortSha() // '6155732'
+   */
+  shortSha(): string {
+    let shortSha = '';
+
+    for (let i = 0; i < 7; i++) {
+      shortSha += this.faker.helpers.arrayElement(this.hexChars);
+    }
+
+    return shortSha;
+  }
+}
diff --git a/src/modules/hacker/index.ts b/src/modules/hacker/index.ts
new file mode 100644
index 00000000..ee1bbc5c
--- /dev/null
+++ b/src/modules/hacker/index.ts
@@ -0,0 +1,94 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate hacker/IT words and phrases.
+ */
+export class Hacker {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Hacker.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a random hacker/IT abbreviation.
+   *
+   * @example
+   * faker.hacker.abbreviation() // 'THX'
+   */
+  abbreviation(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.hacker.abbreviation
+    );
+  }
+
+  /**
+   * Returns a random hacker/IT adjective.
+   *
+   * @example
+   * faker.hacker.adjective() // 'cross-platform'
+   */
+  adjective(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.hacker.adjective
+    );
+  }
+
+  /**
+   * Returns a random hacker/IT noun.
+   *
+   * @example
+   * faker.hacker.noun() // 'system'
+   */
+  noun(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.hacker.noun);
+  }
+
+  /**
+   * Returns a random hacker/IT verb.
+   *
+   * @example
+   * faker.hacker.verb() // 'copy'
+   */
+  verb(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.hacker.verb);
+  }
+
+  /**
+   * Returns a random hacker/IT verb for continuous actions (en: ing suffix; e.g. hacking).
+   *
+   * @example
+   * faker.hacker.ingverb() // 'navigating'
+   */
+  ingverb(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.hacker.ingverb
+    );
+  }
+
+  /**
+   * Generates a random hacker/IT phrase.
+   *
+   * @example
+   * faker.hacker.phrase()
+   * // 'If we override the card, we can get to the HDD feed through the back-end HDD sensor!'
+   */
+  phrase(): string {
+    const data = {
+      abbreviation: this.abbreviation,
+      adjective: this.adjective,
+      ingverb: this.ingverb,
+      noun: this.noun,
+      verb: this.verb,
+    };
+
+    const phrase = this.faker.helpers.arrayElement(
+      this.faker.definitions.hacker.phrase
+    );
+    return this.faker.helpers.mustache(phrase, data);
+  }
+}
diff --git a/src/modules/helpers/index.ts b/src/modules/helpers/index.ts
new file mode 100644
index 00000000..1b28ddfa
--- /dev/null
+++ b/src/modules/helpers/index.ts
@@ -0,0 +1,810 @@
+import type { Faker } from '../..';
+import { deprecated } from '../../internal/deprecated';
+
+/**
+ * A full card with various details.
+ */
+export interface Card {
+  name: string;
+  username: string;
+  email: string;
+  address: {
+    streetA: string;
+    streetB: string;
+    streetC: string;
+    streetD: string;
+    city: string;
+    state: string;
+    country: string;
+    zipcode: string;
+    geo: {
+      lat: string;
+      lng: string;
+    };
+  };
+  phone: string;
+  website: string;
+  company: {
+    name: string;
+    catchPhrase: string;
+    bs: string;
+  };
+  posts: Array<{
+    words: string;
+    sentence: string;
+    sentences: string;
+    paragraph: string;
+  }>;
+  accountHistory: Array<{
+    amount: string;
+    date: Date;
+    business: string;
+    name: string;
+    type: string;
+    account: string;
+  }>;
+}
+
+/**
+ * A persons card with various details attempting to use a consistent context.
+ */
+export interface ContextualCard {
+  name: string;
+  username: string;
+  avatar: string;
+  email: string;
+  dob: Date;
+  phone: string;
+  address: {
+    street: string;
+    suite: string;
+    city: string;
+    zipcode: string;
+    geo: {
+      lat: string;
+      lng: string;
+    };
+  };
+  website: string;
+  company: {
+    name: string;
+    catchPhrase: string;
+    bs: string;
+  };
+}
+
+/**
+ * A user card with various details.
+ */
+export interface UserCard {
+  name: string;
+  username: string;
+  email: string;
+  address: {
+    street: string;
+    suite: string;
+    city: string;
+    zipcode: string;
+    geo: {
+      lat: string;
+      lng: string;
+    };
+  };
+  phone: string;
+  website: string;
+  company: {
+    name: string;
+    catchPhrase: string;
+    bs: string;
+  };
+}
+
+/**
+ * A transaction info.
+ */
+export interface Transaction {
+  amount: string;
+  date: Date;
+  business: string;
+  name: string;
+  type: string;
+  account: string;
+}
+
+/**
+ * Module with various helper methods that transform the method input rather than returning values from locales.
+ * The transformation process may call methods that use the locale data.
+ */
+export class Helpers {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Helpers.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Backward-compatibility. Use `faker.helpers.arrayElement()` instead.
+   *
+   * Takes an array and returns a random element of the array.
+   *
+   * @template T The type of the entries to pick from.
+   * @param array The array to select an element from.
+   *
+   * @see faker.helpers.arrayElement()
+   *
+   * @example
+   * faker.helpers.randomize() // 'c'
+   * faker.helpers.randomize([1, 2, 3]) // '2'
+   *
+   * @deprecated
+   */
+  randomize<T = string>(
+    array: ReadonlyArray<T> = ['a', 'b', 'c'] as unknown as ReadonlyArray<T>
+  ): T {
+    deprecated({
+      deprecated: 'faker.helpers.randomize()',
+      proposed: 'faker.helpers.arrayElement()',
+      // since: 'v5.0.0', (?)
+      until: 'v7.0.0',
+    });
+    return this.arrayElement(array);
+  }
+
+  /**
+   * Slugifies the given string.
+   * For that all spaces (` `) are replaced by hyphens (`-`)
+   * and most non word characters except for dots and hyphens will be removed.
+   *
+   * @param string The input to slugify.
+   *
+   * @example
+   * faker.helpers.slugify() // ''
+   * faker.helpers.slugify("Hello world!") // 'Hello-world'
+   */
+  slugify(string: string = ''): string {
+    return string
+      .replace(/ /g, '-')
+      .replace(/[^\一-龠\ぁ-ゔ\ァ-ヴー\w\.\-]+/g, '');
+  }
+
+  /**
+   * Parses the given string symbol by symbol and replaces the placeholders with digits (`0` - `9`).
+   * `!` will be replaced by digits >=2 (`2` - `9`).
+   *
+   * @param string The template string to parse.
+   * @param symbol The symbol to replace with digits. Defaults to `'#'`.
+   *
+   * @example
+   * faker.helpers.replaceSymbolWithNumber() // ''
+   * faker.helpers.replaceSymbolWithNumber('#####') // '04812'
+   * faker.helpers.replaceSymbolWithNumber('!####') // '27378'
+   * faker.helpers.replaceSymbolWithNumber('Your pin is: !####') // '29841'
+   */
+  replaceSymbolWithNumber(string: string = '', symbol: string = '#'): string {
+    let str = '';
+    for (let i = 0; i < string.length; i++) {
+      if (string.charAt(i) === symbol) {
+        str += this.faker.datatype.number(9);
+      } else if (string.charAt(i) === '!') {
+        str += this.faker.datatype.number({ min: 2, max: 9 });
+      } else {
+        str += string.charAt(i);
+      }
+    }
+    return str;
+  }
+
+  /**
+   * Parses the given string symbol by symbols and replaces the placeholder appropriately.
+   *
+   * - `#` will be replaced with a digit (`0` - `9`).
+   * - `?` will be replaced with an upper letter ('A' - 'Z')
+   * - and `*` will be replaced with either a digit or letter.
+   *
+   * @param string The template string to parse.
+   *
+   * @example
+   * faker.helpers.replaceSymbols() // ''
+   * faker.helpers.replaceSymbols('#####') // '98441'
+   * faker.helpers.replaceSymbols('?????') // 'ZYRQQ'
+   * faker.helpers.replaceSymbols('*****') // '4Z3P7'
+   * faker.helpers.replaceSymbols('Your pin is: #?*#?*') // '0T85L1'
+   */
+  replaceSymbols(string: string = ''): string {
+    const alpha = [
+      'A',
+      'B',
+      'C',
+      'D',
+      'E',
+      'F',
+      'G',
+      'H',
+      'I',
+      'J',
+      'K',
+      'L',
+      'M',
+      'N',
+      'O',
+      'P',
+      'Q',
+      'R',
+      'S',
+      'T',
+      'U',
+      'V',
+      'W',
+      'X',
+      'Y',
+      'Z',
+    ];
+    let str = '';
+
+    for (let i = 0; i < string.length; i++) {
+      if (string.charAt(i) === '#') {
+        str += this.faker.datatype.number(9);
+      } else if (string.charAt(i) === '?') {
+        str += this.arrayElement(alpha);
+      } else if (string.charAt(i) === '*') {
+        str += this.faker.datatype.boolean()
+          ? this.arrayElement(alpha)
+          : this.faker.datatype.number(9);
+      } else {
+        str += string.charAt(i);
+      }
+    }
+    return str;
+  }
+
+  /**
+   * Replaces the symbols and patterns in a credit card schema including Luhn checksum.
+   *
+   * This method supports both range patterns `[4-9]` as well as the patterns used by `replaceSymbolWithNumber()`.
+   * `L` will be replaced with the appropriate Luhn checksum.
+   *
+   * @param string The credit card format pattern. Defaults to `6453-####-####-####-###L`.
+   * @param symbol The symbol to replace with a digit.
+   *
+   * @example
+   * faker.helpers.replaceCreditCardSymbols() // '6453-4876-8626-8995-3779'
+   * faker.helpers.replaceCreditCardSymbols('1234-[4-9]-##!!-L') // '1234-9-5298-2'
+   */
+  replaceCreditCardSymbols(
+    string: string = '6453-####-####-####-###L',
+    symbol: string = '#'
+  ): string {
+    // default values required for calling method without arguments
+
+    // Function calculating the Luhn checksum of a number string
+    const getCheckBit = (number: number[]) => {
+      number.reverse();
+      number = number.map((num, index) => {
+        if (index % 2 === 0) {
+          num *= 2;
+          if (num > 9) {
+            num -= 9;
+          }
+        }
+        return num;
+      });
+      const sum = number.reduce((prev, curr) => prev + curr);
+      return sum % 10;
+    };
+
+    string = this.regexpStyleStringParse(string); // replace [4-9] with a random number in range etc...
+    string = this.replaceSymbolWithNumber(string, symbol); // replace ### with random numbers
+
+    const numberList = string
+      .replace(/\D/g, '')
+      .split('')
+      .map((num) => parseInt(num));
+    const checkNum = getCheckBit(numberList);
+    return string.replace('L', String(checkNum));
+  }
+
+  /**
+   * Repeats the given string the given number of times.
+   *
+   * @param string The string to repeat. Defaults to `''`.
+   * @param num The number of times to repeat it. Defaults to `0`.
+   *
+   * @example
+   * faker.helpers.repeatString('Hello world! ') // ''
+   * faker.helpers.repeatString('Hello world! ', 1) // 'Hello world! '
+   * faker.helpers.repeatString('Hello world! ', 2) // 'Hello world! Hello world! '
+   */
+  repeatString(string = '', num = 0): string {
+    let text = '';
+    for (let i = 0; i < num; i++) {
+      text += string.toString();
+    }
+    return text;
+  }
+
+  /**
+   * Replaces the regex like expressions in the given string with matching values.
+   *
+   * Supported patterns:
+   * - `.{times}` => Repeat the character exactly `times` times.
+   * - `.{min,max}` => Repeat the character `min` to `max` times.
+   * - `[min-max]` => Generate a number between min and max (inclusive).
+   *
+   * @param string The template string to to parse.
+   *
+   * @example
+   * faker.helpers.regexpStyleStringParse() // ''
+   * faker.helpers.regexpStyleStringParse('#{5}') // '#####'
+   * faker.helpers.regexpStyleStringParse('#{2,9}') // '#######'
+   * faker.helpers.regexpStyleStringParse('[500-15000]') // '8375'
+   * faker.helpers.regexpStyleStringParse('#{3}test[1-5]') // '###test3'
+   */
+  regexpStyleStringParse(string: string = ''): string {
+    // Deal with range repeat `{min,max}`
+    const RANGE_REP_REG = /(.)\{(\d+)\,(\d+)\}/;
+    const REP_REG = /(.)\{(\d+)\}/;
+    const RANGE_REG = /\[(\d+)\-(\d+)\]/;
+    let min: number;
+    let max: number;
+    let tmp: number;
+    let repetitions: number;
+    let token = string.match(RANGE_REP_REG);
+    while (token != null) {
+      min = parseInt(token[2]);
+      max = parseInt(token[3]);
+      // switch min and max
+      if (min > max) {
+        tmp = max;
+        max = min;
+        min = tmp;
+      }
+      repetitions = this.faker.datatype.number({ min: min, max: max });
+      string =
+        string.slice(0, token.index) +
+        this.repeatString(token[1], repetitions) +
+        string.slice(token.index + token[0].length);
+      token = string.match(RANGE_REP_REG);
+    }
+    // Deal with repeat `{num}`
+    token = string.match(REP_REG);
+    while (token != null) {
+      repetitions = parseInt(token[2]);
+      string =
+        string.slice(0, token.index) +
+        this.repeatString(token[1], repetitions) +
+        string.slice(token.index + token[0].length);
+      token = string.match(REP_REG);
+    }
+    // Deal with range `[min-max]` (only works with numbers for now)
+    //TODO: implement for letters e.g. [0-9a-zA-Z] etc.
+
+    token = string.match(RANGE_REG);
+    while (token != null) {
+      min = parseInt(token[1]); // This time we are not capturing the char before `[]`
+      max = parseInt(token[2]);
+      // switch min and max
+      if (min > max) {
+        tmp = max;
+        max = min;
+        min = tmp;
+      }
+      string =
+        string.slice(0, token.index) +
+        this.faker.datatype.number({ min: min, max: max }).toString() +
+        string.slice(token.index + token[0].length);
+      token = string.match(RANGE_REG);
+    }
+    return string;
+  }
+
+  /**
+   * Takes an array and randomizes it in place then returns it.
+   *
+   * Uses the modern version of the Fisher–Yates algorithm.
+   *
+   * @template T The type of the entries to shuffle.
+   * @param o The array to shuffle. Defaults to `[]`.
+   *
+   * @example
+   * faker.helpers.shuffle() // []
+   * faker.helpers.shuffle(['a', 'b', 'c']) // [ 'b', 'c', 'a' ]
+   */
+  shuffle<T>(o?: T[]): T[] {
+    if (o == null || o.length === 0) {
+      return o || [];
+    }
+
+    for (let i = o.length - 1; i > 0; --i) {
+      const j = this.faker.datatype.number(i);
+      const x = o[i];
+      o[i] = o[j];
+      o[j] = x;
+    }
+    return o;
+  }
+
+  /**
+   * Takes an array of strings or function that returns a string
+   * and outputs a unique array of strings based on that source.
+   * This method does not store the unique state between invocations.
+   *
+   * @template T The type of the entries.
+   * @param source The strings to choose from or a function that generates a string.
+   * @param length The number of elements to generate.
+   *
+   * @example
+   * faker.helpers.uniqueArray(faker.random.word, 50)
+   * faker.helpers.uniqueArray(faker.definitions.name.first_name, 6)
+   * faker.helpers.uniqueArray(["Hello", "World", "Goodbye"], 2)
+   */
+  uniqueArray<T>(source: readonly T[] | (() => T), length: number): T[] {
+    if (Array.isArray(source)) {
+      const set = new Set<T>(source);
+      const array = Array.from(set);
+      return this.shuffle(array).splice(0, length);
+    }
+    const set = new Set<T>();
+    try {
+      if (typeof source === 'function') {
+        while (set.size < length) {
+          set.add(source());
+        }
+      }
+    } catch {
+      // Ignore
+    }
+    return Array.from(set);
+  }
+
+  /**
+   * Replaces the `{{placeholder}}` patterns in the given string mustache style.
+   *
+   * @param str The template string to parse.
+   * @param data The data used to populate the placeholders.
+   * This is a record where the key is the template placeholder,
+   * whereas the value is either a string or a function suitable for `String.replace()`.
+   *
+   * @example
+   * faker.helpers.mustache('I found {{count}} instances of "{{word}}".', {
+   *   count: () => `${faker.datatype.number()}`,
+   *   word: "this word",
+   * }) // 'I found 57591 instances of "this word".'
+   */
+  mustache(
+    str: string | undefined,
+    data: Record<string, string | Parameters<string['replace']>[1]>
+  ): string {
+    if (str == null) {
+      return '';
+    }
+    for (const p in data) {
+      const re = new RegExp(`{{${p}}}`, 'g');
+      const value = data[p];
+      if (typeof value === 'string') {
+        str = str.replace(re, value);
+      } else {
+        str = str.replace(re, value);
+      }
+    }
+    return str;
+  }
+
+  /**
+   * Generates a full card with various random details.
+   *
+   * @example
+   * faker.helpers.createCard()
+   * // {
+   * //   name: 'Maxine Abbott',
+   * //   username: 'Idell_Kautzer60',
+   * //   email: '[email protected]',
+   * //   address: {
+   * //     streetA: 'Drake Avenue',
+   * // ...
+   * @deprecated If you need some specific object you should create your own method.
+   */
+  createCard(): Card {
+    deprecated({
+      deprecated: 'helpers.createCard()',
+      proposed: 'a self-build function',
+      since: 'v6.1.0',
+      until: 'v7.0.0',
+    });
+    return {
+      name: this.faker.name.findName(),
+      username: this.faker.internet.userName(),
+      email: this.faker.internet.email(),
+      address: {
+        streetA: this.faker.address.streetName(),
+        streetB: this.faker.address.streetAddress(),
+        streetC: this.faker.address.streetAddress(true),
+        streetD: this.faker.address.secondaryAddress(),
+        city: this.faker.address.city(),
+        state: this.faker.address.state(),
+        country: this.faker.address.country(),
+        zipcode: this.faker.address.zipCode(),
+        geo: {
+          lat: this.faker.address.latitude(),
+          lng: this.faker.address.longitude(),
+        },
+      },
+      phone: this.faker.phone.phoneNumber(),
+      website: this.faker.internet.domainName(),
+      company: {
+        name: this.faker.company.companyName(),
+        catchPhrase: this.faker.company.catchPhrase(),
+        bs: this.faker.company.bs(),
+      },
+      posts: [
+        {
+          words: this.faker.lorem.words(),
+          sentence: this.faker.lorem.sentence(),
+          sentences: this.faker.lorem.sentences(),
+          paragraph: this.faker.lorem.paragraph(),
+        },
+        {
+          words: this.faker.lorem.words(),
+          sentence: this.faker.lorem.sentence(),
+          sentences: this.faker.lorem.sentences(),
+          paragraph: this.faker.lorem.paragraph(),
+        },
+        {
+          words: this.faker.lorem.words(),
+          sentence: this.faker.lorem.sentence(),
+          sentences: this.faker.lorem.sentences(),
+          paragraph: this.faker.lorem.paragraph(),
+        },
+      ],
+      accountHistory: [
+        this.createTransaction(),
+        this.createTransaction(),
+        this.createTransaction(),
+      ],
+    };
+  }
+
+  /**
+   * Generates a persons card with various details attempting to use a consistent context.
+   *
+   * @example
+   * faker.helpers.contextualCard()
+   * // {
+   * //   name: 'Eveline',
+   * //   username: 'Eveline.Brekke56',
+   * //   avatar: 'https://cloudflare-ipfs.com/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/122.jpg',
+   * //   email: '[email protected]',
+   * //   dob: 1964-05-06T05:14:37.874Z,
+   * // ...
+   * @deprecated If you need some specific object you should create your own method.
+   */
+  contextualCard(): ContextualCard {
+    deprecated({
+      deprecated: 'helpers.contextualCard()',
+      proposed: 'a self-build function',
+      since: 'v6.1.0',
+      until: 'v7.0.0',
+    });
+    const name = this.faker.name.firstName();
+    const userName = this.faker.internet.userName(name);
+    return {
+      name: name,
+      username: userName,
+      avatar: this.faker.internet.avatar(),
+      email: this.faker.internet.email(userName),
+      dob: this.faker.date.past(
+        50,
+        new Date('Sat Sep 20 1992 21:35:02 GMT+0200 (CEST)')
+      ),
+      phone: this.faker.phone.phoneNumber(),
+      address: {
+        street: this.faker.address.streetName(),
+        suite: this.faker.address.secondaryAddress(),
+        city: this.faker.address.city(),
+        zipcode: this.faker.address.zipCode(),
+        geo: {
+          lat: this.faker.address.latitude(),
+          lng: this.faker.address.longitude(),
+        },
+      },
+      website: this.faker.internet.domainName(),
+      company: {
+        name: this.faker.company.companyName(),
+        catchPhrase: this.faker.company.catchPhrase(),
+        bs: this.faker.company.bs(),
+      },
+    };
+  }
+
+  /**
+   * Generates a user card with various details.
+   *
+   * @example
+   * faker.helpers.userCard()
+   * // {
+   * //   name: 'Jodi Ferry',
+   * //   username: 'Maybell.Kris',
+   * //   email: '[email protected]',
+   * //   address: {
+   * //     street: 'McKenzie Estates',
+   * // ....
+   * @deprecated If you need some specific object you should create your own method.
+   */
+  userCard(): UserCard {
+    deprecated({
+      deprecated: 'helpers.userCard()',
+      proposed: 'a self-build function',
+      since: 'v6.1.0',
+      until: 'v7.0.0',
+    });
+    return {
+      name: this.faker.name.findName(),
+      username: this.faker.internet.userName(),
+      email: this.faker.internet.email(),
+      address: {
+        street: this.faker.address.streetName(),
+        suite: this.faker.address.secondaryAddress(),
+        city: this.faker.address.city(),
+        zipcode: this.faker.address.zipCode(),
+        geo: {
+          lat: this.faker.address.latitude(),
+          lng: this.faker.address.longitude(),
+        },
+      },
+      phone: this.faker.phone.phoneNumber(),
+      website: this.faker.internet.domainName(),
+      company: {
+        name: this.faker.company.companyName(),
+        catchPhrase: this.faker.company.catchPhrase(),
+        bs: this.faker.company.bs(),
+      },
+    };
+  }
+
+  /**
+   * Generates an example transaction.
+   *
+   * @example
+   * faker.helpers.createTransaction()
+   * // {
+   * //   amount: '551.32',
+   * //   date: 2012-02-01T23:00:00.000Z,
+   * //   business: 'Will, Fisher and Marks',
+   * //   name: 'Investment Account (...8755)',
+   * //   type: 'invoice',
+   * //   account: '41796240'
+   * // }
+   */
+  createTransaction(): Transaction {
+    return {
+      amount: this.faker.finance.amount(),
+      date: new Date(2012, 1, 2), // TODO: add a ranged date method
+      business: this.faker.company.companyName(),
+      name: [this.faker.finance.accountName(), this.faker.finance.mask()].join(
+        ' '
+      ),
+      type: this.arrayElement(this.faker.definitions.finance.transaction_type),
+      account: this.faker.finance.account(),
+    };
+  }
+
+  /**
+   * Returns the result of the callback if the probability check was successful, otherwise `undefined`.
+   *
+   * @template T The type of result of the given callback.
+   * @param callback The callback to that will be invoked if the probability check was successful.
+   * @param options The options to use. Defaults to `{}`.
+   * @param options.probability The probability (`[0.00, 1.00]`) of the callback being invoked. Defaults to `0.5`.
+   *
+   * @example
+   * faker.helpers.maybe(() => 'Hello World!') // 'Hello World!'
+   * faker.helpers.maybe(() => 'Hello World!', { probability: 0.1 }) // undefined
+   * faker.helpers.maybe(() => 'Hello World!', { probability: 0.9 }) // 'Hello World!'
+   */
+  maybe<T>(
+    callback: () => T,
+    options: { probability?: number } = {}
+  ): T | undefined {
+    const { probability = 0.5 } = options;
+    if (this.faker.datatype.float({ min: 0, max: 1 }) < probability) {
+      return callback();
+    }
+    return undefined;
+  }
+
+  /**
+   * Returns a random key from given object or `undefined` if no key could be found.
+   *
+   * @param object The object to be used.
+   *
+   * @example
+   * faker.helpers.objectKey({ myProperty: 'myValue' }) // 'myProperty'
+   */
+  objectKey<T extends Record<string, unknown>>(object: T): keyof T {
+    const array: Array<keyof T> = Object.keys(object);
+    return this.arrayElement(array);
+  }
+
+  /**
+   * Returns a random value from given object or `undefined` if no key could be found.
+   *
+   * @param object The object to be used.
+   *
+   * @example
+   * faker.helpers.objectValue({ myProperty: 'myValue' }) // 'myValue'
+   */
+  objectValue<T extends Record<string, unknown>>(object: T): T[keyof T] {
+    const key = this.faker.helpers.objectKey(object);
+    return object[key];
+  }
+
+  /**
+   * Returns random element from the given array.
+   *
+   * @template T The type of the entries to pick from.
+   * @param array Array to pick the value from.
+   *
+   * @example
+   * faker.helpers.arrayElement(['cat', 'dog', 'mouse']) // 'dog'
+   */
+  arrayElement<T = string>(
+    // TODO @Shinigami92 2022-04-30: We want to remove this default value, but currently it's not possible because some definitions could be empty
+    // See https://github.com/faker-js/faker/issues/893
+    array: ReadonlyArray<T> = ['a', 'b', 'c'] as unknown as ReadonlyArray<T>
+  ): T {
+    const index =
+      array.length > 1
+        ? this.faker.datatype.number({ max: array.length - 1 })
+        : 0;
+
+    return array[index];
+  }
+
+  /**
+   * Returns a subset with random elements of the given array in random order.
+   *
+   * @template T The type of the entries to pick from.
+   * @param array Array to pick the value from.
+   * @param count Number of elements to pick.
+   *    When not provided, random number of elements will be picked.
+   *    When value exceeds array boundaries, it will be limited to stay inside.
+   *
+   * @example
+   * faker.helpers.arrayElements(['cat', 'dog', 'mouse']) // ['mouse', 'cat']
+   * faker.helpers.arrayElements([1, 2, 3, 4, 5], 2) // [4, 2]
+   */
+  arrayElements<T>(
+    // TODO @Shinigami92 2022-04-30: We want to remove this default value, but currently it's not possible because some definitions could be empty
+    // See https://github.com/faker-js/faker/issues/893
+    array: ReadonlyArray<T> = ['a', 'b', 'c'] as unknown as ReadonlyArray<T>,
+    count?: number
+  ): T[] {
+    if (typeof count !== 'number') {
+      count = this.faker.datatype.number({ min: 1, max: array.length });
+    } else if (count > array.length) {
+      count = array.length;
+    } else if (count < 0) {
+      count = 0;
+    }
+
+    const arrayCopy = array.slice(0);
+    let i = array.length;
+    const min = i - count;
+    let temp: T;
+    let index: number;
+
+    while (i-- > min) {
+      index = Math.floor(
+        (i + 1) * this.faker.datatype.float({ min: 0, max: 0.99 })
+      );
+      temp = arrayCopy[index];
+      arrayCopy[index] = arrayCopy[i];
+      arrayCopy[i] = temp;
+    }
+
+    return arrayCopy.slice(min);
+  }
+}
diff --git a/src/modules/image/index.ts b/src/modules/image/index.ts
new file mode 100644
index 00000000..9e8e1879
--- /dev/null
+++ b/src/modules/image/index.ts
@@ -0,0 +1,345 @@
+import type { Faker } from '../..';
+import type { MethodsOf } from '../../utils/types';
+import { LoremPicsum } from './providers/lorempicsum';
+import { Lorempixel } from './providers/lorempixel';
+import { Unsplash } from './providers/unsplash';
+
+/**
+ * Module to generate placeholder images.
+ *
+ * Default provider is unsplash image provider.
+ */
+export class Image {
+  readonly lorempixel: Lorempixel;
+  readonly unsplash: Unsplash;
+  readonly lorempicsum: LoremPicsum;
+
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Image.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+
+    this.lorempixel = new Lorempixel(this.faker);
+    this.unsplash = new Unsplash(this.faker);
+    this.lorempicsum = new LoremPicsum(this.faker);
+  }
+
+  /**
+   * Generates a random image url from one of the supported categories.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.image() // 'http://loremflickr.com/640/480/city'
+   * faker.image.image(1234, 2345) // 'http://loremflickr.com/1234/2345/sports'
+   * faker.image.image(1234, 2345, true) // 'http://loremflickr.com/1234/2345/nature?56789'
+   */
+  image(width?: number, height?: number, randomize?: boolean): string {
+    const categories: MethodsOf<Image, Image['image']> = [
+      'abstract',
+      'animals',
+      'business',
+      'cats',
+      'city',
+      'food',
+      'nightlife',
+      'fashion',
+      'people',
+      'nature',
+      'sports',
+      'technics',
+      'transport',
+    ];
+    return this[this.faker.helpers.arrayElement(categories)](
+      width,
+      height,
+      randomize
+    );
+  }
+
+  /**
+   * Generates a random avatar image url.
+   *
+   * @example
+   * faker.image.avatar()
+   * // 'https://cloudflare-ipfs.com/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/170.jpg'
+   */
+  avatar(): string {
+    return this.faker.internet.avatar();
+  }
+
+  /**
+   * Generates a random image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param category The category of the image. By default, a random one will be selected.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   * @param https When true, return a `https` url. Otherwise, return a `http` url.
+   *
+   * @example
+   * faker.image.imageUrl() // 'http://loremflickr.com/640/480'
+   * faker.image.imageUrl(1234, 2345) // 'http://loremflickr.com/1234/2345'
+   * faker.image.imageUrl(1234, 2345, 'cat') // 'http://loremflickr.com/1234/2345/cat'
+   * faker.image.imageUrl(1234, 2345, 'cat', true) // 'http://loremflickr.com/1234/2345/cat?6849'
+   * faker.image.imageUrl(1234, 2345, 'cat', true, true) // 'https://loremflickr.com/1234/2345/cat?56789'
+   */
+  imageUrl(
+    width?: number,
+    height?: number,
+    category?: string,
+    randomize?: boolean,
+    https?: boolean
+  ): string {
+    width = width || 640;
+    height = height || 480;
+    let protocol = 'http://';
+    if (https === true) {
+      protocol = 'https://';
+    }
+    let url = `${protocol}loremflickr.com/${width}/${height}`;
+    if (category != null) {
+      url += `/${category}`;
+    }
+
+    if (randomize) {
+      url += `?${this.faker.datatype.number()}`;
+    }
+
+    return url;
+  }
+
+  /**
+   * Generates a random abstract image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.abstract() // 'http://loremflickr.com/640/480/abstract'
+   * faker.image.abstract(1234, 2345) // 'http://loremflickr.com/1234/2345/abstract'
+   * faker.image.abstract(1234, 2345, true) // 'http://loremflickr.com/1234/2345/abstract?56789'
+   */
+  abstract(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'abstract', randomize);
+  }
+
+  /**
+   * Generates a random animal image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.animals() // 'http://loremflickr.com/640/480/animals'
+   * faker.image.animals(1234, 2345) // 'http://loremflickr.com/1234/2345/animals'
+   * faker.image.animals(1234, 2345, true) // 'http://loremflickr.com/1234/2345/animals?56789'
+   */
+  animals(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'animals', randomize);
+  }
+
+  /**
+   * Generates a random business image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.business() // 'http://loremflickr.com/640/480/business'
+   * faker.image.business(1234, 2345) // 'http://loremflickr.com/1234/2345/business'
+   * faker.image.business(1234, 2345, true) // 'http://loremflickr.com/1234/2345/business?56789'
+   */
+  business(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'business', randomize);
+  }
+
+  /**
+   * Generates a random cat image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.cats() // 'http://loremflickr.com/640/480/cats'
+   * faker.image.cats(1234, 2345) // 'http://loremflickr.com/1234/2345/cats'
+   * faker.image.cats(1234, 2345, true) // 'http://loremflickr.com/1234/2345/cats?56789'
+   */
+  cats(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'cats', randomize);
+  }
+
+  /**
+   * Generates a random city image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.city() // 'http://loremflickr.com/640/480/city'
+   * faker.image.city(1234, 2345) // 'http://loremflickr.com/1234/2345/city'
+   * faker.image.city(1234, 2345, true) // 'http://loremflickr.com/1234/2345/city?56789'
+   */
+  city(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'city', randomize);
+  }
+
+  /**
+   * Generates a random food image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.food() // 'http://loremflickr.com/640/480/food'
+   * faker.image.food(1234, 2345) // 'http://loremflickr.com/1234/2345/food'
+   * faker.image.food(1234, 2345, true) // 'http://loremflickr.com/1234/2345/food?56789'
+   */
+  food(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'food', randomize);
+  }
+
+  /**
+   * Generates a random nightlife image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.nightlife() // 'http://loremflickr.com/640/480/nightlife'
+   * faker.image.nightlife(1234, 2345) // 'http://loremflickr.com/1234/2345/nightlife'
+   * faker.image.nightlife(1234, 2345, true) // 'http://loremflickr.com/1234/2345/nightlife?56789'
+   */
+  nightlife(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'nightlife', randomize);
+  }
+
+  /**
+   * Generates a random fashion image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.fashion() // 'http://loremflickr.com/640/480/fashion'
+   * faker.image.fashion(1234, 2345) // 'http://loremflickr.com/1234/2345/fashion'
+   * faker.image.fashion(1234, 2345, true) // 'http://loremflickr.com/1234/2345/fashion?56789'
+   */
+  fashion(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'fashion', randomize);
+  }
+
+  /**
+   * Generates a random people image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.people() // 'http://loremflickr.com/640/480/people'
+   * faker.image.people(1234, 2345) // 'http://loremflickr.com/1234/2345/people'
+   * faker.image.people(1234, 2345, true) // 'http://loremflickr.com/1234/2345/people?56789'
+   */
+  people(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'people', randomize);
+  }
+
+  /**
+   * Generates a random nature image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.nature() // 'http://loremflickr.com/640/480/nature'
+   * faker.image.nature(1234, 2345) // 'http://loremflickr.com/1234/2345/nature'
+   * faker.image.nature(1234, 2345, true) // 'http://loremflickr.com/1234/2345/nature?56789'
+   */
+  nature(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'nature', randomize);
+  }
+
+  /**
+   * Generates a random sports image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.sports() // 'http://loremflickr.com/640/480/sports'
+   * faker.image.sports(1234, 2345) // 'http://loremflickr.com/1234/2345/sports'
+   * faker.image.sports(1234, 2345, true) // 'http://loremflickr.com/1234/2345/sports?56789'
+   */
+  sports(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'sports', randomize);
+  }
+
+  /**
+   * Generates a random technics image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.technics() // 'http://loremflickr.com/640/480/technics'
+   * faker.image.technics(1234, 2345) // 'http://loremflickr.com/1234/2345/technics'
+   * faker.image.technics(1234, 2345, true) // 'http://loremflickr.com/1234/2345/technics?56789'
+   */
+  technics(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'technics', randomize);
+  }
+
+  /**
+   * Generates a random transport image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to randomize the image or not. Defaults to `false`.
+   *
+   * @example
+   * faker.image.transport() // 'http://loremflickr.com/640/480/transport'
+   * faker.image.transport(1234, 2345) // 'http://loremflickr.com/1234/2345/transport'
+   * faker.image.transport(1234, 2345, true) // 'http://loremflickr.com/1234/2345/transport?56789'
+   */
+  transport(width?: number, height?: number, randomize?: boolean): string {
+    return this.imageUrl(width, height, 'transport', randomize);
+  }
+
+  /**
+   * Generates a random data uri containing an svg image.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param color The color to use. Defaults to `grey`.
+   *
+   * @example
+   * faker.image.dataUri() // 'data:image/svg+xml;charset=UTF-8,%3Csvg%20xmlns%3D%22http...'
+   */
+  dataUri(width?: number, height?: number, color: string = 'grey'): string {
+    const svgString = `<svg xmlns="http://www.w3.org/2000/svg" version="1.1" baseProfile="full" width="${width}" height="${height}"><rect width="100%" height="100%" fill="${color}"/><text x="${
+      width / 2
+    }" y="${
+      height / 2
+    }" font-size="20" alignment-baseline="middle" text-anchor="middle" fill="white">${width}x${height}</text></svg>`;
+    const rawPrefix = 'data:image/svg+xml;charset=UTF-8,';
+    return rawPrefix + encodeURIComponent(svgString);
+  }
+}
diff --git a/src/modules/image/providers/lorempicsum.ts b/src/modules/image/providers/lorempicsum.ts
new file mode 100644
index 00000000..25869205
--- /dev/null
+++ b/src/modules/image/providers/lorempicsum.ts
@@ -0,0 +1,126 @@
+import type { Faker } from '../../..';
+
+/**
+ * Module to generate links to random images on `https://picsum.photos/`.
+ */
+// TODO ST-DDT 2022-03-11: Rename to picsum?
+export class LoremPicsum {
+  constructor(private readonly faker: Faker) {}
+
+  /**
+   * Generates a new picsum image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param grayscale Whether to return a grayscale image. Default to `false`.
+   * @param blur The optional level of blur to apply. Supports `1` - `10`.
+   */
+  image(
+    width?: number,
+    height?: number,
+    grayscale?: boolean,
+    blur?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
+  ): string {
+    return this.imageUrl(width, height, grayscale, blur);
+  }
+
+  /**
+   * Generates a new picsum image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param grayscale Whether to return a grayscale image. Default to `false`.
+   */
+  imageGrayscale(width?: number, height?: number, grayscale?: boolean): string {
+    return this.imageUrl(width, height, grayscale);
+  }
+
+  /**
+   * Generates a new picsum image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param blur The optional level of blur to apply. Supports `1` - `10`.
+   */
+  imageBlurred(
+    width?: number,
+    height?: number,
+    blur?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
+  ): string {
+    return this.imageUrl(width, height, undefined, blur);
+  }
+
+  /**
+   * Generates a new picsum image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param grayscale Whether to return a grayscale image. Default to `false`.
+   * @param blur The optional level of blur to apply. Supports `1` - `10`.
+   * @param seed The optional seed to use.
+   */
+  imageRandomSeeded(
+    width?: number,
+    height?: number,
+    grayscale?: boolean,
+    blur?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10,
+    seed?: string
+  ): string {
+    // TODO ST-DDT 2022-03-11: This method does the same as image url, maybe generate a seed, if it is missig?
+    return this.imageUrl(width, height, grayscale, blur, seed);
+  }
+
+  /**
+   * Returns a random avatar url.
+   *
+   * @example
+   * faker.internet.avatar()
+   * // 'https://cloudflare-ipfs.com/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/315.jpg'
+   */
+  // TODO ST-DDT 2022-03-11: Deprecate this method as it is duplicate and has nothing to do with lorempicsum.
+  avatar(): string {
+    return this.faker.internet.avatar();
+  }
+
+  /**
+   * Generates a new picsum image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param grayscale Whether to return a grayscale image. Default to `false`.
+   * @param blur The optional level of blur to apply. Supports `1` - `10`.
+   * @param seed The optional seed to use.
+   */
+  imageUrl(
+    width?: number,
+    height?: number,
+    grayscale?: boolean,
+    blur?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10,
+    seed?: string
+  ): string {
+    width = width || 640;
+    height = height || 480;
+
+    let url = 'https://picsum.photos';
+
+    if (seed) {
+      url += `/seed/${seed}`;
+    }
+
+    url += `/${width}/${height}`;
+
+    if (grayscale && blur) {
+      return `${url}?grayscale&blur=${blur}`;
+    }
+
+    if (grayscale) {
+      return `${url}?grayscale`;
+    }
+
+    if (blur) {
+      return `${url}?blur=${blur}`;
+    }
+
+    return url;
+  }
+}
diff --git a/src/modules/image/providers/lorempixel.ts b/src/modules/image/providers/lorempixel.ts
new file mode 100644
index 00000000..f1ab384b
--- /dev/null
+++ b/src/modules/image/providers/lorempixel.ts
@@ -0,0 +1,288 @@
+import type { Faker } from '../../..';
+import type { MethodsOf } from '../../../utils/types';
+
+/**
+ * Module to generate links to random images on `https://lorempixel.com/`.
+ */
+export class Lorempixel {
+  constructor(private readonly faker: Faker) {}
+
+  /**
+   * Generates a new lorempixel image url for a random supported category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  image(width?: number, height?: number, randomize?: boolean): string {
+    const categories: MethodsOf<Lorempixel, Lorempixel['image']> = [
+      'abstract',
+      'animals',
+      'business',
+      'cats',
+      'city',
+      'food',
+      'nightlife',
+      'fashion',
+      'people',
+      'nature',
+      'sports',
+      'technics',
+      'transport',
+    ];
+    return this[this.faker.helpers.arrayElement(categories)](
+      width,
+      height,
+      randomize
+    );
+  }
+
+  /**
+   * Returns a random avatar url.
+   *
+   * @example
+   * faker.internet.avatar()
+   * // 'https://cloudflare-ipfs.com/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/315.jpg'
+   */
+  // TODO ST-DDT 2022-03-11: Deprecate this method as it is duplicate and has nothing to do with lorempixel.
+  avatar(): string {
+    return this.faker.internet.avatar();
+  }
+
+  /**
+   * Generates a new lorempixel image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param category The category of the image to generate.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  imageUrl(
+    width?: number,
+    height?: number,
+    category?: string,
+    randomize?: boolean
+  ): string {
+    width = width || 640;
+    height = height || 480;
+
+    let url = `https://lorempixel.com/${width}/${height}`;
+    if (category != null) {
+      url += `/${category}`;
+    }
+
+    if (randomize) {
+      url += `?${this.faker.datatype.number()}`;
+    }
+
+    return url;
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "abstract" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  abstract(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'abstract',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "animals" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  animals(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'animals',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "business" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  business(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'business',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "cats" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  cats(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'cats',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "city" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  city(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'city',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "food" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  food(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'food',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "nightlife" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  nightlife(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'nightlife',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "fashion" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  fashion(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'fashion',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "people" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  people(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'people',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "nature" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  nature(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'nature',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "sports" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  sports(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'sports',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "technics" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  technics(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'technics',
+      randomize
+    );
+  }
+
+  /**
+   * Generates a new lorempixel image url using the "transport" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param randomize Whether to append a seed to the url. Defaults to `false`.
+   */
+  transport(width?: number, height?: number, randomize?: boolean): string {
+    return this.faker.image.lorempixel.imageUrl(
+      width,
+      height,
+      'transport',
+      randomize
+    );
+  }
+}
diff --git a/src/modules/image/providers/unsplash.ts b/src/modules/image/providers/unsplash.ts
new file mode 100644
index 00000000..45bd815c
--- /dev/null
+++ b/src/modules/image/providers/unsplash.ts
@@ -0,0 +1,157 @@
+import type { Faker } from '../../..';
+
+/**
+ * Module to generate links to random images on `https://source.unsplash.com/`.
+ */
+export class Unsplash {
+  // TODO ST-DDT 2022-03-11: Remove unused(?) constant
+  categories = [
+    'food',
+    'nature',
+    'people',
+    'technology',
+    'objects',
+    'buildings',
+  ];
+
+  constructor(private readonly faker: Faker) {}
+
+  /**
+   * Generates a new unsplash image url for a random supported category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param keyword The image keywords to use.
+   */
+  image(width?: number, height?: number, keyword?: string): string {
+    return this.imageUrl(width, height, undefined, keyword);
+  }
+
+  /**
+   * Returns a random avatar url.
+   *
+   * @example
+   * faker.internet.avatar()
+   * // 'https://cloudflare-ipfs.com/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/315.jpg'
+   */
+  // TODO ST-DDT 2022-03-11: Deprecate this method as it is duplicate and has nothing to do with unsplash.
+  avatar(): string {
+    return this.faker.internet.avatar();
+  }
+
+  /**
+   * Generates a new unsplash image url.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param category The category of the image to generate.
+   * @param keyword The image keywords to use.
+   */
+  imageUrl(
+    width?: number,
+    height?: number,
+    category?: string,
+    keyword?: string
+  ): string {
+    width = width || 640;
+    height = height || 480;
+
+    let url = 'https://source.unsplash.com';
+
+    if (category != null) {
+      url += `/category/${category}`;
+    }
+
+    url += `/${width}x${height}`;
+
+    if (keyword != null) {
+      const keywordFormat = /^([A-Za-z0-9].+,[A-Za-z0-9]+)$|^([A-Za-z0-9]+)$/;
+      if (keywordFormat.test(keyword)) {
+        url += `?${keyword}`;
+      }
+    }
+
+    return url;
+  }
+
+  /**
+   * Generates a new unsplash image url using the "food" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param keyword The image keywords to use.
+   */
+  food(width?: number, height?: number, keyword?: string): string {
+    return this.faker.image.unsplash.imageUrl(width, height, 'food', keyword);
+  }
+
+  /**
+   * Generates a new unsplash image url using the "people" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param keyword The image keywords to use.
+   */
+  people(width?: number, height?: number, keyword?: string): string {
+    return this.faker.image.unsplash.imageUrl(width, height, 'people', keyword);
+  }
+
+  /**
+   * Generates a new unsplash image url using the "nature" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param keyword The image keywords to use.
+   */
+  nature(width?: number, height?: number, keyword?: string): string {
+    return this.faker.image.unsplash.imageUrl(width, height, 'nature', keyword);
+  }
+
+  /**
+   * Generates a new unsplash image url using the "technology" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param keyword The image keywords to use.
+   */
+  technology(width?: number, height?: number, keyword?: string): string {
+    return this.faker.image.unsplash.imageUrl(
+      width,
+      height,
+      'technology',
+      keyword
+    );
+  }
+
+  /**
+   * Generates a new unsplash image url using the "objects" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param keyword The image keywords to use.
+   */
+  objects(width?: number, height?: number, keyword?: string): string {
+    return this.faker.image.unsplash.imageUrl(
+      width,
+      height,
+      'objects',
+      keyword
+    );
+  }
+
+  /**
+   * Generates a new unsplash image url using the "buildings" category.
+   *
+   * @param width The width of the image. Defaults to `640`.
+   * @param height The height of the image. Defaults to `480`.
+   * @param keyword The image keywords to use.
+   */
+  buildings(width?: number, height?: number, keyword?: string): string {
+    return this.faker.image.unsplash.imageUrl(
+      width,
+      height,
+      'buildings',
+      keyword
+    );
+  }
+}
diff --git a/src/modules/internet/index.ts b/src/modules/internet/index.ts
new file mode 100644
index 00000000..bcc5daf3
--- /dev/null
+++ b/src/modules/internet/index.ts
@@ -0,0 +1,458 @@
+import type { Faker } from '../..';
+import * as random_ua from './user-agent';
+
+export type EmojiType =
+  | 'smiley'
+  | 'body'
+  | 'person'
+  | 'nature'
+  | 'food'
+  | 'travel'
+  | 'activity'
+  | 'object'
+  | 'symbol'
+  | 'flag';
+
+/**
+ * Module to generate internet related entries.
+ */
+export class Internet {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Internet.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a random avatar url.
+   *
+   * @example
+   * faker.internet.avatar()
+   * // 'https://cloudflare-ipfs.com/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/315.jpg'
+   */
+  avatar(): string {
+    return `https://cloudflare-ipfs.com/ipfs/Qmd3W5DuhgHirLHGVixi6V76LhCkZUz6pnFt5AJBiyvHye/avatar/${this.faker.datatype.number(
+      1249
+    )}.jpg`;
+  }
+
+  /**
+   * Generates an email address using the given person's name as base.
+   *
+   * @param firstName The optional first name to use. If not specified, a random one will be chosen.
+   * @param lastName The optional last name to use. If not specified, a random one will be chosen.
+   * @param provider The mail provider domain to use. If not specified, a random free mail provider will be chosen.
+   * @param options The options to use. Defaults to `{ allowSpecialCharacters: false }`.
+   * @param options.allowSpecialCharacters Whether special characters such as ``.!#$%&'*+-/=?^_`{|}~`` should be included
+   * in the email address. Defaults to `false`.
+   *
+   * @example
+   * faker.internet.email() // '[email protected]'
+   * faker.internet.email('Jeanne', 'Doe') // '[email protected]'
+   * faker.internet.email('Jeanne', 'Doe', 'example.fakerjs.dev') // '[email protected]'
+   * faker.internet.email('Jeanne', 'Doe', 'example.fakerjs.dev', { allowSpecialCharacters: true }) // 'Jeanne%[email protected]'
+   */
+  email(
+    firstName?: string,
+    lastName?: string,
+    provider?: string,
+    options?: { allowSpecialCharacters?: boolean }
+  ): string {
+    provider =
+      provider ||
+      this.faker.helpers.arrayElement(
+        this.faker.definitions.internet.free_email
+      );
+
+    let localPart: string = this.faker.helpers.slugify(
+      this.userName(firstName, lastName)
+    );
+
+    if (options?.allowSpecialCharacters) {
+      const usernameChars: string[] = '._-'.split('');
+      const specialChars: string[] = ".!#$%&'*+-/=?^_`{|}~".split('');
+      localPart = localPart.replace(
+        this.faker.helpers.arrayElement(usernameChars),
+        this.faker.helpers.arrayElement(specialChars)
+      );
+    }
+
+    return `${localPart}@${provider}`;
+  }
+
+  /**
+   * Generates an email address using an example mail provider using the given person's name as base.
+   *
+   * @param firstName The optional first name to use. If not specified, a random one will be chosen.
+   * @param lastName The optional last name to use. If not specified, a random one will be chosen.
+   * @param options The options to use. Defaults to `{ allowSpecialCharacters: false }`.
+   * @param options.allowSpecialCharacters Whether special characters such as ``.!#$%&'*+-/=?^_`{|}~`` should be included
+   * in the email address. Defaults to `false`.
+   *
+   * @example
+   * faker.internet.exampleEmail() // '[email protected]'
+   * faker.internet.exampleEmail('Jeanne', 'Doe') // '[email protected]'
+   * faker.internet.exampleEmail('Jeanne', 'Doe', { allowSpecialCharacters: true }) // 'Jeanne%[email protected]'
+   */
+  exampleEmail(
+    firstName?: string,
+    lastName?: string,
+    options?: { allowSpecialCharacters?: boolean }
+  ): string {
+    const provider = this.faker.helpers.arrayElement(
+      this.faker.definitions.internet.example_email
+    );
+    return this.email(firstName, lastName, provider, options);
+  }
+
+  /**
+   * Generates a username using the given person's name as base.
+   *
+   * @param firstName The optional first name to use. If not specified, a random one will be chosen.
+   * @param lastName The optional last name to use. If not specified, a random one will be chosen.
+   *
+   * @example
+   * faker.internet.userName() // 'Nettie_Zboncak40'
+   * faker.internet.userName('Jeanne', 'Doe') // 'Jeanne98'
+   */
+  userName(firstName?: string, lastName?: string): string {
+    let result: string;
+    firstName = firstName || this.faker.name.firstName();
+    lastName = lastName || this.faker.name.lastName();
+    switch (this.faker.datatype.number(2)) {
+      case 0:
+        result = `${firstName}${this.faker.datatype.number(99)}`;
+        break;
+      case 1:
+        result =
+          firstName + this.faker.helpers.arrayElement(['.', '_']) + lastName;
+        break;
+      case 2:
+        result = `${firstName}${this.faker.helpers.arrayElement([
+          '.',
+          '_',
+        ])}${lastName}${this.faker.datatype.number(99)}`;
+        break;
+    }
+    result = result.toString().replace(/'/g, '');
+    result = result.replace(/ /g, '');
+    return result;
+  }
+
+  /**
+   * Returns a random web protocol. Either `http` or `https`.
+   *
+   * @example
+   * faker.internet.protocol() // 'http'
+   * faker.internet.protocol() // 'https'
+   */
+  protocol(): 'http' | 'https' {
+    const protocols: ['http', 'https'] = ['http', 'https'];
+    return this.faker.helpers.arrayElement(protocols);
+  }
+
+  /**
+   * Returns a random http method.
+   *
+   * Can be either of the following:
+   *
+   * - `GET`
+   * - `POST`
+   * - `PUT`
+   * - `DELETE`
+   * - `PATCH`
+   *
+   * @example
+   * faker.internet.httpMethod() // 'PATCH'
+   */
+  httpMethod(): 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' {
+    const httpMethods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] = [
+      'GET',
+      'POST',
+      'PUT',
+      'DELETE',
+      'PATCH',
+    ];
+    return this.faker.helpers.arrayElement(httpMethods);
+  }
+
+  /**
+   * Generates a random url.
+   *
+   * @example
+   * faker.internet.url() // 'https://remarkable-hackwork.info'
+   */
+  url(): string {
+    return `${this.protocol()}://${this.domainName()}`;
+  }
+
+  /**
+   * Generates a random domain name.
+   *
+   * @example
+   * faker.internet.domainName() // 'slow-timer.info'
+   */
+  domainName(): string {
+    return `${this.domainWord()}.${this.domainSuffix()}`;
+  }
+
+  /**
+   * Returns a random domain suffix.
+   *
+   * @example
+   * faker.internet.domainSuffix() // 'com'
+   * faker.internet.domainSuffix() // 'name'
+   */
+  domainSuffix(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.internet.domain_suffix
+    );
+  }
+
+  /**
+   * Generates a random domain word.
+   *
+   * @example
+   * faker.internet.domainWord() // 'close-reality'
+   * faker.internet.domainWord() // 'weird-cytoplasm'
+   */
+  domainWord(): string {
+    return `${this.faker.word.adjective()}-${this.faker.word.noun()}`
+      .replace(/([\\~#&*{}/:<>?|\"'])/gi, '')
+      .replace(/\s/g, '-')
+      .replace(/-{2,}/g, '-')
+      .toLowerCase();
+  }
+
+  /**
+   * Generates a random IPv4 address.
+   *
+   * @example
+   * faker.internet.ip() // '245.108.222.0'
+   */
+  ip(): string {
+    // TODO @Shinigami92 2022-03-21: We may want to return a IPv4 or IPv6 address here in a later major release
+    return this.ipv4();
+  }
+
+  /**
+   * Generates a random IPv4 address.
+   *
+   * @example
+   * faker.internet.ipv4() // '245.108.222.0'
+   */
+  ipv4(): string {
+    const randNum = () => {
+      return this.faker.datatype.number(255).toFixed(0);
+    };
+
+    const result: string[] = [];
+    for (let i = 0; i < 4; i++) {
+      result[i] = randNum();
+    }
+
+    return result.join('.');
+  }
+
+  /**
+   * Generates a random IPv6 address.
+   *
+   * @example
+   * faker.internet.ipv6() // '269f:1230:73e3:318d:842b:daab:326d:897b'
+   */
+  ipv6(): string {
+    const randHash = () => {
+      let result = '';
+      for (let i = 0; i < 4; i++) {
+        result += this.faker.helpers.arrayElement([
+          '0',
+          '1',
+          '2',
+          '3',
+          '4',
+          '5',
+          '6',
+          '7',
+          '8',
+          '9',
+          'a',
+          'b',
+          'c',
+          'd',
+          'e',
+          'f',
+        ]);
+      }
+      return result;
+    };
+
+    const result: string[] = [];
+    for (let i = 0; i < 8; i++) {
+      result[i] = randHash();
+    }
+    return result.join(':');
+  }
+
+  /**
+   * Generates a random port number.
+   *
+   * @example
+   * faker.internet.port() // '9414'
+   */
+  port(): number {
+    return this.faker.datatype.number({ min: 0, max: 65535 });
+  }
+
+  /**
+   * Generates a random user agent string.
+   *
+   * @example
+   * faker.internet.userAgent()
+   * // 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_8_8)  AppleWebKit/536.0.2 (KHTML, like Gecko) Chrome/27.0.849.0 Safari/536.0.2'
+   */
+  userAgent(): string {
+    return random_ua.generate(this.faker);
+  }
+
+  /**
+   * Generates a random css hex color code in aesthetically pleasing color palette.
+   *
+   * Based on
+   * http://stackoverflow.com/questions/43044/algorithm-to-randomly-generate-an-aesthetically-pleasing-color-palette
+   *
+   * @param redBase The optional base red in range between `0` and `255`. Defaults to `0`.
+   * @param greenBase The optional base green in range between `0` and `255`. Defaults to `0`.
+   * @param blueBase The optional base blue in range between `0` and `255`. Defaults to `0`.
+   *
+   * @example
+   * faker.internet.color() // '#30686e'
+   * faker.internet.color(100, 100, 100) // '#4e5f8b'
+   */
+  color(
+    redBase: number = 0,
+    greenBase: number = 0,
+    blueBase: number = 0
+  ): string {
+    const colorFromBase = (base: number): string =>
+      Math.floor((this.faker.datatype.number(256) + base) / 2)
+        .toString(16)
+        .padStart(2, '0');
+
+    const red = colorFromBase(redBase);
+    const green = colorFromBase(greenBase);
+    const blue = colorFromBase(blueBase);
+
+    return `#${red}${green}${blue}`;
+  }
+
+  /**
+   * Generates a random mac address.
+   *
+   * @param sep The optional separator to use. Can be either `':'`, `'-'` or `''`. Defaults to `':'`.
+   *
+   * @example
+   * faker.internet.mac() // '32:8e:2e:09:c6:05'
+   */
+  mac(sep?: string): string {
+    let i: number;
+    let mac = '';
+    let validSep = ':';
+
+    // if the client passed in a different separator than `:`,
+    // we will use it if it is in the list of acceptable separators (dash or no separator)
+    if (['-', ''].indexOf(sep) !== -1) {
+      validSep = sep;
+    }
+
+    for (i = 0; i < 12; i++) {
+      mac += this.faker.datatype.number(15).toString(16);
+      if (i % 2 === 1 && i !== 11) {
+        mac += validSep;
+      }
+    }
+    return mac;
+  }
+
+  /**
+   * Generates a random password.
+   *
+   * @param len The length of the password to generate. Defaults to `15`.
+   * @param memorable Whether the generated password should be memorable. Defaults to `false`.
+   * @param pattern The pattern that all chars should match should match.
+   * This option will be ignored, if `memorable` is `true`. Defaults to `/\w/`.
+   * @param prefix The prefix to use. Defaults to `''`.
+   *
+   * @example
+   * faker.internet.password() // '89G1wJuBLbGziIs'
+   * faker.internet.password(20) // 'aF55c_8O9kZaPOrysFB_'
+   * faker.internet.password(20, true) // 'lawetimufozujosodedi'
+   * faker.internet.password(20, true, /[A-Z]/) // 'HMAQDFFYLDDUTBKVNFVS'
+   * faker.internet.password(20, true, /[A-Z]/, 'Hello ') // 'Hello IREOXTDWPERQSB'
+   */
+  password(
+    len: number = 15,
+    memorable: boolean = false,
+    pattern: RegExp = /\w/,
+    prefix: string = ''
+  ): string {
+    /*
+     * password-generator ( function )
+     * Copyright(c) 2011-2013 Bermi Ferrer <[email protected]>
+     * MIT Licensed
+     */
+    const vowel = /[aeiouAEIOU]$/;
+    const consonant = /[bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ]$/;
+    const _password = (
+      length: number,
+      memorable: boolean,
+      pattern: RegExp,
+      prefix: string
+    ): string => {
+      if (prefix.length >= length) {
+        return prefix;
+      }
+      if (memorable) {
+        if (prefix.match(consonant)) {
+          pattern = vowel;
+        } else {
+          pattern = consonant;
+        }
+      }
+      const n = this.faker.datatype.number(94) + 33;
+      let char = String.fromCharCode(n);
+      if (memorable) {
+        char = char.toLowerCase();
+      }
+      if (!char.match(pattern)) {
+        return _password(length, memorable, pattern, prefix);
+      }
+      return _password(length, memorable, pattern, prefix + char);
+    };
+    return _password(len, memorable, pattern, prefix);
+  }
+
+  /**
+   * Generates a random emoji.
+   *
+   * @param options Options object.
+   * @param options.types A list of the emoji types that should be used.
+   * @example
+   * faker.internet.emoji() // '🥰'
+   * faker.internet.emoji({ types: ['food', 'nature'] }) // '🥐'
+   */
+  emoji(options: { types?: ReadonlyArray<EmojiType> } = {}): string {
+    const {
+      types = Object.keys(
+        this.faker.definitions.internet.emoji
+      ) as Array<EmojiType>,
+    } = options;
+    const emojiType = this.faker.helpers.arrayElement(types);
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.internet.emoji[emojiType]
+    );
+  }
+}
diff --git a/src/modules/internet/user-agent.ts b/src/modules/internet/user-agent.ts
new file mode 100644
index 00000000..046758d4
--- /dev/null
+++ b/src/modules/internet/user-agent.ts
@@ -0,0 +1,345 @@
+/**
+ * Copyright (c) 2022 Faker
+ *
+ * This is a version of the original code migrated to TypeScript and modified
+ * by the Faker team.
+ *
+ * Check LICENSE for more details about the copyright.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Copyright (c) 2012-2014 Jeffrey Mealo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Based loosely on Luka Pusic's PHP Script:
+ * http://360percents.com/posts/php-random-user-agent-generator/
+ *
+ * The license for that script is as follows:
+ *
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ *
+ * <[email protected]> wrote this file. As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return. Luka Pusic
+ */
+
+import type { Faker } from '../..';
+
+export type Arch = 'lin' | 'mac' | 'win';
+
+export function generate(faker: Faker): string {
+  function rnd(
+    a?: string[] | number | Record<string, number>,
+    b?: number
+  ): string | number {
+    //calling rnd() with no arguments is identical to rnd(0, 100)
+    a = a || 0;
+    b = b || 100;
+
+    if (typeof b === 'number' && typeof a === 'number') {
+      // 9/2018 - Added faker random to ensure mersenne and seed
+      return faker.datatype.number({ min: a, max: b });
+    }
+
+    if (Array.isArray(a)) {
+      //returns a random element from array (a), even weighting
+      return faker.helpers.arrayElement(a);
+    }
+
+    if (a && typeof a === 'object') {
+      //returns a random key from the passed object; keys are weighted by the decimal probability in their value
+      return ((obj) => {
+        const rand = (rnd(0, 100) as number) / 100;
+        let min = 0;
+        let max = 0;
+        let return_val: string;
+
+        for (const key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            max = obj[key] + min;
+            return_val = key;
+            if (rand >= min && rand <= max) {
+              break;
+            }
+            min = min + obj[key];
+          }
+        }
+
+        return return_val;
+      })(a);
+    }
+
+    throw new TypeError(
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Invalid arguments passed to rnd. (${b ? `${a}, ${b}` : a})`
+    );
+  }
+
+  function randomLang(): string | number {
+    return rnd([
+      'AB',
+      'AF',
+      'AN',
+      'AR',
+      'AS',
+      'AZ',
+      'BE',
+      'BG',
+      'BN',
+      'BO',
+      'BR',
+      'BS',
+      'CA',
+      'CE',
+      'CO',
+      'CS',
+      'CU',
+      'CY',
+      'DA',
+      'DE',
+      'EL',
+      'EN',
+      'EO',
+      'ES',
+      'ET',
+      'EU',
+      'FA',
+      'FI',
+      'FJ',
+      'FO',
+      'FR',
+      'FY',
+      'GA',
+      'GD',
+      'GL',
+      'GV',
+      'HE',
+      'HI',
+      'HR',
+      'HT',
+      'HU',
+      'HY',
+      'ID',
+      'IS',
+      'IT',
+      'JA',
+      'JV',
+      'KA',
+      'KG',
+      'KO',
+      'KU',
+      'KW',
+      'KY',
+      'LA',
+      'LB',
+      'LI',
+      'LN',
+      'LT',
+      'LV',
+      'MG',
+      'MK',
+      'MN',
+      'MO',
+      'MS',
+      'MT',
+      'MY',
+      'NB',
+      'NE',
+      'NL',
+      'NN',
+      'NO',
+      'OC',
+      'PL',
+      'PT',
+      'RM',
+      'RO',
+      'RU',
+      'SC',
+      'SE',
+      'SK',
+      'SL',
+      'SO',
+      'SQ',
+      'SR',
+      'SV',
+      'SW',
+      'TK',
+      'TR',
+      'TY',
+      'UK',
+      'UR',
+      'UZ',
+      'VI',
+      'VO',
+      'YI',
+      'ZH',
+    ]);
+  }
+
+  function randomBrowserAndOS(): Array<string | number> {
+    const browser = rnd({
+      chrome: 0.45132810566,
+      iexplorer: 0.27477061836,
+      firefox: 0.19384170608,
+      safari: 0.06186781118,
+      opera: 0.01574236955,
+    });
+    const os = {
+      chrome: { win: 0.89, mac: 0.09, lin: 0.02 },
+      firefox: { win: 0.83, mac: 0.16, lin: 0.01 },
+      opera: { win: 0.91, mac: 0.03, lin: 0.06 },
+      safari: { win: 0.04, mac: 0.96 },
+      iexplorer: ['win'],
+    };
+
+    return [browser, rnd(os[browser])];
+  }
+
+  function randomProc(arch: Arch): string | number {
+    const procs = {
+      lin: ['i686', 'x86_64'],
+      mac: { Intel: 0.48, PPC: 0.01, 'U; Intel': 0.48, 'U; PPC': 0.01 },
+      win: ['', 'WOW64', 'Win64; x64'],
+    };
+    return rnd(procs[arch]);
+  }
+
+  function randomRevision(dots: number): string {
+    let return_val = '';
+    //generate a random revision
+    //dots = 2 returns .x.y where x & y are between 0 and 9
+    for (let x = 0; x < dots; x++) {
+      return_val += `.${rnd(0, 9)}`;
+    }
+    return return_val;
+  }
+
+  const version_string = {
+    net() {
+      return [rnd(1, 4), rnd(0, 9), rnd(10000, 99999), rnd(0, 9)].join('.');
+    },
+    nt() {
+      return `${rnd(5, 6)}.${rnd(0, 3)}`;
+    },
+    ie() {
+      return rnd(7, 11);
+    },
+    trident() {
+      return `${rnd(3, 7)}.${rnd(0, 1)}`;
+    },
+    osx(delim?: string) {
+      return [10, rnd(5, 10), rnd(0, 9)].join(delim || '.');
+    },
+    chrome() {
+      return [rnd(13, 39), 0, rnd(800, 899), 0].join('.');
+    },
+    presto() {
+      return `2.9.${rnd(160, 190)}`;
+    },
+    presto2() {
+      return `${rnd(10, 12)}.00`;
+    },
+    safari() {
+      return `${rnd(531, 538)}.${rnd(0, 2)}.${rnd(0, 2)}`;
+    },
+  };
+
+  const browser = {
+    firefox(arch: Arch): string {
+      //https://developer.mozilla.org/en-US/docs/Gecko_user_agent_string_reference
+      const firefox_ver = `${rnd(5, 15)}${randomRevision(2)}`,
+        gecko_ver = `Gecko/20100101 Firefox/${firefox_ver}`,
+        proc = randomProc(arch),
+        os_ver =
+          arch === 'win'
+            ? `(Windows NT ${version_string.nt()}${proc ? `; ${proc}` : ''}`
+            : arch === 'mac'
+            ? `(Macintosh; ${proc} Mac OS X ${version_string.osx()}`
+            : `(X11; Linux ${proc}`;
+
+      return `Mozilla/5.0 ${os_ver}; rv:${firefox_ver.slice(
+        0,
+        -2
+      )}) ${gecko_ver}`;
+    },
+
+    iexplorer(): string {
+      const ver = version_string.ie();
+
+      if (ver >= 11) {
+        //http://msdn.microsoft.com/en-us/library/ie/hh869301(v=vs.85).aspx
+        return `Mozilla/5.0 (Windows NT 6.${rnd(1, 3)}; Trident/7.0; ${rnd([
+          'Touch; ',
+          '',
+        ])}rv:11.0) like Gecko`;
+      }
+
+      //http://msdn.microsoft.com/en-us/library/ie/ms537503(v=vs.85).aspx
+      return `Mozilla/5.0 (compatible; MSIE ${ver}.0; Windows NT ${version_string.nt()}; Trident/${version_string.trident()}${
+        rnd(0, 1) === 1 ? `; .NET CLR ${version_string.net()}` : ''
+      })`;
+    },
+
+    opera(arch: Arch): string {
+      //http://www.opera.com/docs/history/
+      const presto_ver = ` Presto/${version_string.presto()} Version/${version_string.presto2()})`,
+        os_ver =
+          arch === 'win'
+            ? `(Windows NT ${version_string.nt()}; U; ${randomLang()}${presto_ver}`
+            : arch === 'lin'
+            ? `(X11; Linux ${randomProc(arch)}; U; ${randomLang()}${presto_ver}`
+            : `(Macintosh; Intel Mac OS X ${version_string.osx()} U; ${randomLang()} Presto/${version_string.presto()} Version/${version_string.presto2()})`;
+
+      return `Opera/${rnd(9, 14)}.${rnd(0, 99)} ${os_ver}`;
+    },
+
+    safari(arch: Arch): string {
+      const safari = version_string.safari(),
+        ver = `${rnd(4, 7)}.${rnd(0, 1)}.${rnd(0, 10)}`,
+        os_ver =
+          arch === 'mac'
+            ? `(Macintosh; ${randomProc('mac')} Mac OS X ${version_string.osx(
+                '_'
+              )} rv:${rnd(2, 6)}.0; ${randomLang()}) `
+            : `(Windows; U; Windows NT ${version_string.nt()})`;
+
+      return `Mozilla/5.0 ${os_ver}AppleWebKit/${safari} (KHTML, like Gecko) Version/${ver} Safari/${safari}`;
+    },
+
+    chrome(arch: Arch): string {
+      const safari = version_string.safari(),
+        os_ver =
+          arch === 'mac'
+            ? `(Macintosh; ${randomProc('mac')} Mac OS X ${version_string.osx(
+                '_'
+              )}) `
+            : arch === 'win'
+            ? `(Windows; U; Windows NT ${version_string.nt()})`
+            : `(X11; Linux ${randomProc(arch)}`;
+
+      return `Mozilla/5.0 ${os_ver} AppleWebKit/${safari} (KHTML, like Gecko) Chrome/${version_string.chrome()} Safari/${safari}`;
+    },
+  };
+
+  const random = randomBrowserAndOS();
+  return browser[random[0]](random[1]);
+}
diff --git a/src/modules/lorem/index.ts b/src/modules/lorem/index.ts
new file mode 100644
index 00000000..5df39146
--- /dev/null
+++ b/src/modules/lorem/index.ts
@@ -0,0 +1,205 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate random texts and words.
+ */
+export class Lorem {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Lorem.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generates a word of a specified length.
+   *
+   * @param length length of the word that should be returned. Defaults to a random length.
+   *
+   * @example
+   * faker.lorem.word() // 'temporibus'
+   * faker.lorem.word(5) // 'velit'
+   */
+  word(length?: number): string {
+    const hasRightLength = (word: string) => word.length === length;
+    let properLengthWords: readonly string[];
+    if (length == null) {
+      properLengthWords = this.faker.definitions.lorem.words;
+    } else {
+      properLengthWords =
+        this.faker.definitions.lorem.words.filter(hasRightLength);
+    }
+    return this.faker.helpers.arrayElement(properLengthWords);
+  }
+
+  /**
+   * Generates a space separated list of words.
+   *
+   * @param num The number of words to generate. Defaults to `3`.
+   *
+   * @example
+   * faker.lorem.words() // 'qui praesentium pariatur'
+   * faker.lorem.words(10) // 'debitis consectetur voluptatem non doloremque ipsum autem totam eum ratione'
+   */
+  words(num: number = 3): string {
+    const words: string[] = [];
+    for (let i = 0; i < num; i++) {
+      words.push(this.word());
+    }
+    return words.join(' ');
+  }
+
+  /**
+   * Generates a space separated list of words beginning a capital letter and ending with a dot.
+   *
+   * @param wordCount The number of words, that should be in the sentence. Defaults to a random number between `3` and `10`.
+   *
+   * @example
+   * faker.lorem.sentence() // 'Voluptatum cupiditate suscipit autem eveniet aut dolorem aut officiis distinctio.'
+   * faker.lorem.sentence(5) // 'Laborum voluptatem officiis est et.'
+   */
+  sentence(wordCount?: number): string {
+    if (wordCount == null) {
+      wordCount = this.faker.datatype.number({ min: 3, max: 10 });
+    }
+
+    const sentence = this.words(wordCount);
+    return `${sentence.charAt(0).toUpperCase() + sentence.slice(1)}.`;
+  }
+
+  /**
+   * Generates a slugified text consisting of the given number of hyphen separated words.
+   *
+   * @param wordCount The number of words to generate. Defaults to `3`.
+   *
+   * @example
+   * faker.lorem.slug() // 'dolores-illo-est'
+   */
+  slug(wordCount?: number): string {
+    const words = this.words(wordCount);
+
+    return this.faker.helpers.slugify(words);
+  }
+
+  /**
+   * Generates the given number of sentences.
+   *
+   * @param sentenceCount The number of sentences to generate. Defaults to a random number between `2` and `6`.
+   * @param separator The separator to add between sentences. Defaults to `' '`.
+   *
+   * @example
+   * faker.lorem.sentences() // 'Iste molestiae incidunt aliquam possimus reprehenderit eum corrupti. Deleniti modi voluptatem nostrum ut esse.'
+   * faker.lorem.sentences(2) // 'Maxime vel numquam quibusdam. Dignissimos ex molestias quos aut molestiae quam nihil occaecati maiores.'
+   * faker.lorem.sentences(2, '\n')
+   * // 'Et rerum a unde tempora magnam sit nisi.
+   * // Et perspiciatis ipsam omnis.'
+   */
+  sentences(sentenceCount?: number, separator: string = ' '): string {
+    if (sentenceCount == null) {
+      sentenceCount = this.faker.datatype.number({ min: 2, max: 6 });
+    }
+    const sentences: string[] = [];
+    for (sentenceCount; sentenceCount > 0; sentenceCount--) {
+      sentences.push(this.sentence());
+    }
+    return sentences.join(separator);
+  }
+
+  /**
+   * Generates a paragraph with at least the given number of sentences.
+   *
+   * @param sentenceCount The minim number of sentences to generate. Defaults to `3`.
+   *
+   * @example
+   * faker.lorem.paragraph() // 'Non architecto nam unde sint. Ex tenetur dolor facere optio aut consequatur. Ea laudantium reiciendis repellendus.'
+   * faker.lorem.paragraph() // 'Animi possimus nemo consequuntur ut ea et tempore unde qui. Quis corporis esse occaecati.'
+   */
+  paragraph(sentenceCount: number = 3): string {
+    return this.sentences(sentenceCount + this.faker.datatype.number(3));
+  }
+
+  /**
+   * Generates the given number of paragraphs.
+   *
+   * @param paragraphCount The number of paragraphs to generate. Defaults to `3`.
+   * @param separator The separator to use. Defaults to `'\n'`.
+   *
+   * @example
+   * faker.lorem.paragraphs()
+   * // 'Beatae voluptatem dicta et assumenda fugit eaque quidem consequatur. Fuga unde provident. Id reprehenderit soluta facilis est laborum laborum. Illum aut non ut. Est nulla rem ipsa.
+   * // Voluptatibus quo pariatur est. Temporibus deleniti occaecati pariatur nemo est molestias voluptas. Doloribus commodi et et exercitationem vel et. Omnis inventore cum aut amet.
+   * // Sapiente deleniti et. Ducimus maiores eum. Rem dolorem itaque aliquam.'
+   *
+   * faker.lorem.paragraphs(5)
+   * // 'Quia hic sunt ducimus expedita quo impedit soluta. Quam impedit et ipsum optio. Unde dolores nulla nobis vero et aspernatur officiis.
+   * // Aliquam dolorem temporibus dolores voluptatem voluptatem qui nostrum quia. Sit hic facilis rerum eius. Beatae doloribus nesciunt iste ipsum.
+   * // Natus nam eum nulla voluptas molestiae fuga libero nihil voluptatibus. Sed quam numquam eum ipsam temporibus eaque ut et. Enim quas debitis quasi quis. Vitae et vitae.
+   * // Repellat voluptatem est laborum illo harum sed reprehenderit aut. Quo sit et. Exercitationem blanditiis totam velit ad dicta placeat.
+   * // Rerum non eum incidunt amet quo. Eaque laborum ut. Recusandae illo ab distinctio veritatis. Cum quis architecto ad maxime a.'
+   *
+   * faker.lorem.paragraphs(2, '<br/>\n')
+   * // 'Eos magnam aut qui accusamus. Sapiente quas culpa totam excepturi. Blanditiis totam distinctio occaecati dignissimos cumque atque qui officiis.<br/>
+   * // Nihil quis vel consequatur. Blanditiis commodi deserunt sunt animi dolorum. A optio porro hic dolorum fugit aut et sint voluptas. Minima ad sed ipsa est non dolores.'
+   */
+  paragraphs(paragraphCount: number = 3, separator: string = '\n'): string {
+    const paragraphs: string[] = [];
+    for (paragraphCount; paragraphCount > 0; paragraphCount--) {
+      paragraphs.push(this.paragraph());
+    }
+    return paragraphs.join(separator);
+  }
+
+  /**
+   * Generates a random text based on a random lorem method.
+   *
+   * @example
+   * faker.lorem.text() // 'Doloribus autem non quis vero quia.'
+   * faker.lorem.text()
+   * // 'Rerum eum reiciendis id ipsa hic dolore aut laborum provident.
+   * // Quis beatae quis corporis veritatis corrupti ratione delectus sapiente ut.
+   * // Quis ut dolor dolores facilis possimus tempore voluptates.
+   * // Iure nam officia optio cumque.
+   * // Dolor tempora iusto.'
+   */
+  text(): string {
+    const methods: Array<keyof Lorem> = [
+      'word',
+      'words',
+      'sentence',
+      'sentences',
+      'paragraph',
+      'paragraphs',
+      'lines',
+    ];
+
+    const method = this.faker.helpers.arrayElement(methods);
+
+    return `${this[method]()}`;
+  }
+
+  /**
+   * Generates the given number lines of lorem separated by `'\n'`.
+   *
+   * @param lineCount The number of lines to generate. Defaults to a random number between `1` and `5`.
+   *
+   * @example
+   * faker.lorem.lines()
+   * // 'Rerum quia aliquam pariatur explicabo sint minima eos.
+   * // Voluptatem repellat consequatur deleniti qui quibusdam harum cumque.
+   * // Enim eveniet a qui.
+   * // Consectetur velit eligendi animi nostrum veritatis.'
+   *
+   * faker.lorem.lines()
+   * // 'Soluta deserunt eos quam reiciendis libero autem enim nam ut.
+   * // Voluptate aut aut.'
+   */
+  lines(lineCount?: number): string {
+    if (lineCount == null) {
+      lineCount = this.faker.datatype.number({ min: 1, max: 5 });
+    }
+    return this.sentences(lineCount, '\n');
+  }
+}
diff --git a/src/modules/mersenne/index.ts b/src/modules/mersenne/index.ts
new file mode 100644
index 00000000..33e610f8
--- /dev/null
+++ b/src/modules/mersenne/index.ts
@@ -0,0 +1,73 @@
+import { FakerError } from '../../errors/faker-error';
+import Gen from './twister';
+
+/**
+ * Module to generate seed based random numbers.
+ */
+export class Mersenne {
+  private gen = new Gen();
+
+  constructor() {
+    this.gen.initGenrand(new Date().getTime() % 1000000000);
+
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Mersenne.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generates a random number between `[min, max)`.
+   *
+   * @param max The maximum number. Defaults to `0`.
+   * @param min The minimum number. Defaults to `32768`.
+   *
+   * @example
+   * faker.mersenne.rand() // 15515
+   * faker.mersenne.rand(500, 1000) // 578
+   */
+  rand(max = 32768, min = 0): number {
+    if (min > max) {
+      const temp = min;
+      min = max;
+      max = temp;
+    }
+
+    return Math.floor(this.gen.genrandReal2() * (max - min) + min);
+  }
+
+  /**
+   * Sets the seed to use.
+   *
+   * @param S The seed to use.
+   * @throws If the seed is not a `number`.
+   */
+  seed(S: number): void {
+    if (typeof S !== 'number') {
+      throw new FakerError(
+        `seed(S) must take numeric argument; is ${typeof S}`
+      );
+    }
+
+    this.gen.initGenrand(S);
+  }
+
+  /**
+   * Sets the seed to use.
+   *
+   * @param A The seed to use.
+   * @throws If the seed is not a `number[]`.
+   */
+  seed_array(A: number[]): void {
+    if (typeof A !== 'object') {
+      throw new FakerError(
+        `seed_array(A) must take array of numbers; is ${typeof A}`
+      );
+    }
+
+    this.gen.initByArray(A, A.length);
+  }
+}
diff --git a/src/modules/mersenne/twister.ts b/src/modules/mersenne/twister.ts
new file mode 100644
index 00000000..5859f3ae
--- /dev/null
+++ b/src/modules/mersenne/twister.ts
@@ -0,0 +1,320 @@
+/**
+ * Copyright (c) 2022 Faker
+ *
+ * This is a version of the original source code migrated to TypeScript and
+ * modified by the Faker team.
+ *
+ * Check LICENSE for more details on copyright.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Copyright (c) 2006 Y. Okada
+ *
+ * This program is a JavaScript version of Mersenne Twister, with concealment
+ * and encapsulation in class, an almost straight conversion from the original
+ * program, mt19937ar.c, translated by Y. Okada on July 17, 2006, and modified
+ * a little at July 20, 2006, but there are not any substantial differences.
+ *
+ * In this program, procedure descriptions and comments of original source code
+ * were not removed.
+ *
+ * Lines commented with //c// were originally descriptions of c procedure.
+ * And a few following lines are appropriate JavaScript descriptions.
+ *
+ * Lines commented with /* and *\/ are original comments.
+ * Lines commented with // are additional comments in this JavaScript version.
+ *
+ * Before using this version, create at least one instance of
+ * MersenneTwister19937 class, and initialize the each state, given below
+ * in C comments, of all the instances.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * A C-program for MT19937, with initialization improved 2002/1/26.
+ * Coded by Takuji Nishimura and Makoto Matsumoto.
+ *
+ * Before using, initialize the state by using init_genrand(seed)
+ * or init_by_array(init_key, key_length).
+ *
+ * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The names of its contributors may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Any feedback is very welcome.
+ *   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+ *   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+ */
+
+export default class MersenneTwister19937 {
+  private readonly N = 624;
+  private readonly M = 397;
+  private readonly MATRIX_A = 0x9908b0df; // constant vector a
+  private readonly UPPER_MASK = 0x80000000; // most significant w-r bits
+  private readonly LOWER_MASK = 0x7fffffff; // least significant r bits
+  private mt: number[] = new Array(this.N); // the array for the state vector
+  private mti = this.N + 1; // mti==N+1 means mt[N] is not initialized
+
+  /**
+   * Returns a 32-bits unsigned integer from an operand to which applied a bit
+   * operator.
+   *
+   * @param n1 number to unsign
+   */
+  private unsigned32(n1: number): number {
+    return n1 < 0 ? (n1 ^ this.UPPER_MASK) + this.UPPER_MASK : n1;
+  }
+
+  /**
+   * Emulates lowerflow of a c 32-bits unsigned integer variable, instead of
+   * the operator -. These both arguments must be non-negative integers
+   * expressible using unsigned 32 bits.
+   *
+   * @param n1 dividend
+   * @param n2 divisor
+   */
+  private subtraction32(n1: number, n2: number): number {
+    return n1 < n2
+      ? this.unsigned32((0x100000000 - (n2 - n1)) & 0xffffffff)
+      : n1 - n2;
+  }
+
+  /**
+   * Emulates overflow of a c 32-bits unsigned integer variable, instead of the operator +.
+   * these both arguments must be non-negative integers expressible using unsigned 32 bits.
+   *
+   * @param n1 number one for addition
+   * @param n2 number two for addition
+   */
+  private addition32(n1: number, n2: number): number {
+    return this.unsigned32((n1 + n2) & 0xffffffff);
+  }
+
+  /**
+   * Emulates overflow of a c 32-bits unsigned integer variable, instead of the operator *.
+   * These both arguments must be non-negative integers expressible using unsigned 32 bits.
+   *
+   * @param n1 number one for multiplication
+   * @param n2 number two for multiplication
+   */
+  private multiplication32(n1: number, n2: number): number {
+    let sum = 0;
+    for (let i = 0; i < 32; ++i) {
+      if ((n1 >>> i) & 0x1) {
+        sum = this.addition32(sum, this.unsigned32(n2 << i));
+      }
+    }
+    return sum;
+  }
+
+  /**
+   * Initializes mt[N] with a seed.
+   *
+   * @param seed the seed to use
+   */
+  initGenrand(seed: number): void {
+    this.mt[0] = this.unsigned32(seed & 0xffffffff);
+    for (this.mti = 1; this.mti < this.N; this.mti++) {
+      this.mt[this.mti] =
+        //(1812433253 * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
+        this.addition32(
+          this.multiplication32(
+            1812433253,
+            this.unsigned32(
+              this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30)
+            )
+          ),
+          this.mti
+        );
+
+      /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+      /* In the previous versions, MSBs of the seed affect   */
+      /* only MSBs of the array mt[].                        */
+      /* 2002/01/09 modified by Makoto Matsumoto             */
+      this.mt[this.mti] = this.unsigned32(this.mt[this.mti] & 0xffffffff);
+    }
+  }
+
+  /**
+   * Initialize by an array with array-length.
+   *
+   * @param initKey is the array for initializing keys
+   * @param keyLength is its length
+   */
+  initByArray(initKey: number[], keyLength: number): void {
+    this.initGenrand(19650218);
+    let i = 1;
+    let j = 0;
+    let k = this.N > keyLength ? this.N : keyLength;
+    for (; k; k--) {
+      // mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525)) + init_key[j] + j;
+      this.mt[i] = this.addition32(
+        this.addition32(
+          this.unsigned32(
+            this.mt[i] ^
+              this.multiplication32(
+                this.unsigned32(this.mt[i - 1] ^ (this.mt[i - 1] >>> 30)),
+                1664525
+              )
+          ),
+          initKey[j]
+        ),
+        j
+      );
+      // mt[i] &= 0xffffffff; for WORDSIZE > 32 machines
+      this.mt[i] = this.unsigned32(this.mt[i] & 0xffffffff);
+      i++;
+      j++;
+      if (i >= this.N) {
+        this.mt[0] = this.mt[this.N - 1];
+        i = 1;
+      }
+      if (j >= keyLength) {
+        j = 0;
+      }
+    }
+    for (k = this.N - 1; k; k--) {
+      // mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941)) - i
+      this.mt[i] = this.subtraction32(
+        this.unsigned32(
+          this.mt[i] ^
+            this.multiplication32(
+              this.unsigned32(this.mt[i - 1] ^ (this.mt[i - 1] >>> 30)),
+              1566083941
+            )
+        ),
+        i
+      );
+      // mt[i] &= 0xffffffff; for WORDSIZE > 32 machines
+      this.mt[i] = this.unsigned32(this.mt[i] & 0xffffffff);
+      i++;
+      if (i >= this.N) {
+        this.mt[0] = this.mt[this.N - 1];
+        i = 1;
+      }
+    }
+    this.mt[0] = 0x80000000; // MSB is 1; assuring non-zero initial array
+  }
+
+  // moved outside of genrandInt32() by jwatte 2010-11-17; generate less garbage
+  private mag01 = [0x0, this.MATRIX_A];
+
+  /**
+   * Generates a random number on [0,2^32]-interval
+   */
+  genrandInt32(): number {
+    let y: number;
+
+    if (this.mti >= this.N) {
+      // generate N words at one time
+      let kk: number;
+
+      // if initGenrand() has not been called a default initial seed is used
+      if (this.mti === this.N + 1) {
+        this.initGenrand(5489);
+      }
+
+      for (kk = 0; kk < this.N - this.M; kk++) {
+        y = this.unsigned32(
+          (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK)
+        );
+
+        this.mt[kk] = this.unsigned32(
+          this.mt[kk + this.M] ^ (y >>> 1) ^ this.mag01[y & 0x1]
+        );
+      }
+
+      for (; kk < this.N - 1; kk++) {
+        y = this.unsigned32(
+          (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK)
+        );
+
+        this.mt[kk] = this.unsigned32(
+          this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ this.mag01[y & 0x1]
+        );
+      }
+
+      y = this.unsigned32(
+        (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK)
+      );
+
+      this.mt[this.N - 1] = this.unsigned32(
+        this.mt[this.M - 1] ^ (y >>> 1) ^ this.mag01[y & 0x1]
+      );
+
+      this.mti = 0;
+    }
+
+    y = this.mt[this.mti++];
+
+    // Tempering
+    y = this.unsigned32(y ^ (y >>> 11));
+    y = this.unsigned32(y ^ ((y << 7) & 0x9d2c5680));
+    y = this.unsigned32(y ^ ((y << 15) & 0xefc60000));
+    y = this.unsigned32(y ^ (y >>> 18));
+
+    return y;
+  }
+
+  /**
+   * Generates a random number on [0,2^32]-interval
+   */
+  genrandInt31(): number {
+    return this.genrandInt32() >>> 1;
+  }
+
+  /**
+   * Generates a random number on [0,1]-real-interval
+   */
+  genrandReal1(): number {
+    return this.genrandInt32() * (1.0 / 4294967295.0); // divided by 2^32-1
+  }
+
+  /**
+   * Generates a random number on [0,1)-real-interval
+   */
+  genrandReal2(): number {
+    return this.genrandInt32() * (1.0 / 4294967296.0); // divided by 2^32
+  }
+
+  /**
+   * Generates a random number on (0,1)-real-interval
+   */
+  genrandReal3(): number {
+    return (this.genrandInt32() + 0.5) * (1.0 / 4294967296.0); // divided by 2^32
+  }
+
+  /**
+   * Generates a random number on [0,1) with 53-bit resolution
+   */
+  genrandRes53(): number {
+    const a = this.genrandInt32() >>> 5,
+      b = this.genrandInt32() >>> 6;
+    return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
+  }
+  // These real versions are due to Isaku Wada, 2002/01/09
+}
diff --git a/src/modules/music/index.ts b/src/modules/music/index.ts
new file mode 100644
index 00000000..a34a4bb8
--- /dev/null
+++ b/src/modules/music/index.ts
@@ -0,0 +1,26 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate music related entries.
+ */
+export class Music {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Music.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a random music genre.
+   *
+   * @example
+   * faker.music.genre() // 'Reggae'
+   */
+  genre(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.music.genre);
+  }
+}
diff --git a/src/modules/name/index.ts b/src/modules/name/index.ts
new file mode 100644
index 00000000..c1ac22a7
--- /dev/null
+++ b/src/modules/name/index.ts
@@ -0,0 +1,350 @@
+import type { Faker } from '../..';
+import { deprecated } from '../../internal/deprecated';
+
+export enum Gender {
+  female = 'female',
+  male = 'male',
+}
+
+// TODO @Shinigami92 2022-03-21: Remove 0 and 1 in v7
+export type GenderType = 'female' | 'male' | 0 | 1;
+
+/**
+ * Normalize gender.
+ *
+ * @param gender Gender.
+ * @param functionName Temporary parameter for deprecation message.
+ * @returns Normalized gender.
+ */
+function normalizeGender(
+  gender?: GenderType,
+  functionName?: string
+): Exclude<GenderType, number> | undefined {
+  if (gender == null || typeof gender === 'string') {
+    // TODO @Shinigami92 2022-03-21: Cast can be removed when we set `strict: true`
+    return gender as Exclude<GenderType, number>;
+  }
+
+  const normalizedGender = gender === 0 ? 'male' : 'female';
+
+  deprecated({
+    deprecated: `name.${functionName}(number)`,
+    proposed: "'female' or 'male'",
+    since: 'v6.1.0',
+    until: 'v7.0.0',
+  });
+
+  return normalizedGender;
+}
+
+/**
+ * Select a definition based on given gender.
+ *
+ * @param faker Faker instance.
+ * @param gender Gender.
+ * @param param2 Definitions.
+ * @param param2.generic Non-gender definitions.
+ * @param param2.female Female definitions.
+ * @param param2.male Male definitions.
+ * @param functionName Temporary parameter for deprecation message.
+ * @returns Definition based on given gender.
+ */
+function selectDefinition(
+  faker: Faker,
+  gender: GenderType | undefined,
+  // TODO @Shinigami92 2022-03-21: Remove fallback empty object when `strict: true`
+  {
+    generic,
+    female,
+    male,
+  }: { generic?: string[]; female?: string[]; male?: string[] } = {},
+  functionName?: string
+) {
+  const normalizedGender = normalizeGender(gender, functionName);
+
+  let values: string[] | undefined;
+  switch (normalizedGender) {
+    case 'female':
+      values = female;
+      break;
+    case 'male':
+      values = male;
+      break;
+    default:
+      values = generic;
+      break;
+  }
+
+  if (values == null) {
+    if (female != null && male != null) {
+      values = faker.helpers.arrayElement([female, male]);
+    } else {
+      values = generic;
+    }
+  }
+
+  return faker.helpers.arrayElement(values);
+}
+
+/**
+ * Module to generate people's names and titles.
+ */
+export class Name {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Name.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a random first name.
+   *
+   * @param gender The optional gender to use.
+   * Can be either `'female'` or `'male'`.
+   *
+   * @example
+   * faker.name.firstName() // 'Antwan'
+   * faker.name.firstName("female") // 'Victoria'
+   * faker.name.firstName("male") // 'Tom'
+   */
+  firstName(gender?: GenderType): string {
+    const { first_name, female_first_name, male_first_name } =
+      this.faker.definitions.name;
+
+    return selectDefinition(
+      this.faker,
+      gender,
+      {
+        generic: first_name,
+        female: female_first_name,
+        male: male_first_name,
+      },
+      'firstName'
+    );
+  }
+
+  /**
+   * Returns a random last name.
+   *
+   * @param gender The optional gender to use.
+   * Can be either `'female'` or `'male'`.
+   *
+   * @example
+   * faker.name.lastName() // 'Hauck'
+   * faker.name.lastName("female") // 'Grady'
+   * faker.name.lastName("male") // 'Barton'
+   */
+  lastName(gender?: GenderType): string {
+    const { last_name, female_last_name, male_last_name } =
+      this.faker.definitions.name;
+
+    return selectDefinition(
+      this.faker,
+      gender,
+      {
+        generic: last_name,
+        female: female_last_name,
+        male: male_last_name,
+      },
+      'lastName'
+    );
+  }
+
+  /**
+   * Returns a random middle name.
+   *
+   * @param gender The optional gender to use.
+   * Can be either `'female'` or `'male'`.
+   *
+   * @example
+   * faker.name.middleName() // 'Доброславівна'
+   * faker.name.middleName("female") // 'Анастасівна'
+   * faker.name.middleName("male") // 'Вікторович'
+   */
+  middleName(gender?: GenderType): string {
+    const { middle_name, female_middle_name, male_middle_name } =
+      this.faker.definitions.name;
+
+    return selectDefinition(
+      this.faker,
+      gender,
+      {
+        generic: middle_name,
+        female: female_middle_name,
+        male: male_middle_name,
+      },
+      'middleName'
+    );
+  }
+
+  /**
+   * Generates a random full name.
+   *
+   * @param firstName The optional first name to use. If not specified a random one will be chosen.
+   * @param lastName The optional last name to use. If not specified a random one will be chosen.
+   * @param gender The optional gender to use.
+   * Can be either `'female'` or `'male'`.
+   *
+   * @example
+   * faker.name.findName() // 'Allen Brown'
+   * faker.name.findName('Joann') // 'Joann Osinski'
+   * faker.name.findName('Marcella', '', 'female') // 'Mrs. Marcella Huels'
+   * faker.name.findName(undefined, 'Beer') // 'Mr. Alfonso Beer'
+   * faker.name.findName(undefined, undefined, 'male') // 'Fernando Schaefer'
+   */
+  findName(firstName?: string, lastName?: string, gender?: GenderType): string {
+    const variant = this.faker.datatype.number(8);
+    let prefix = '';
+    let suffix = '';
+
+    const normalizedGender: Exclude<GenderType, number> =
+      normalizeGender(gender, 'findName') ??
+      this.faker.helpers.arrayElement(['female', 'male']);
+
+    firstName = firstName || this.firstName(normalizedGender);
+    lastName = lastName || this.lastName(normalizedGender);
+
+    switch (variant) {
+      // TODO @Shinigami92 2022-03-21: Add possibility to have a prefix together with a suffix
+      case 0:
+        prefix = this.prefix(gender);
+        if (prefix) {
+          return `${prefix} ${firstName} ${lastName}`;
+        }
+      // TODO @Shinigami92 2022-01-21: Not sure if this fallthrough is wanted
+      // eslint-disable-next-line no-fallthrough
+      case 1:
+        suffix = this.suffix();
+        if (suffix) {
+          return `${firstName} ${lastName} ${suffix}`;
+        }
+    }
+
+    return `${firstName} ${lastName}`;
+  }
+
+  /**
+   * Return a random gender.
+   *
+   * @param binary Whether to return only binary gender names. Defaults to `false`.
+   *
+   * @example
+   * faker.name.gender() // 'Trans*Man'
+   * faker.name.gender(true) // 'Female'
+   */
+  gender(binary?: boolean): string {
+    if (binary) {
+      return this.faker.helpers.arrayElement(
+        this.faker.definitions.name.binary_gender
+      );
+    }
+
+    return this.faker.helpers.arrayElement(this.faker.definitions.name.gender);
+  }
+
+  /**
+   * Returns a random name prefix.
+   *
+   * @param gender The optional gender to use.
+   * Can be either `'female'` or `'male'`.
+   *
+   * @example
+   * faker.name.prefix() // 'Miss'
+   * faker.name.prefix('female') // 'Ms.'
+   * faker.name.prefix('male') // 'Mr.'
+   */
+  prefix(gender?: GenderType): string {
+    const { prefix, female_prefix, male_prefix } = this.faker.definitions.name;
+
+    return selectDefinition(
+      this.faker,
+      gender,
+      {
+        generic: prefix,
+        female: female_prefix,
+        male: male_prefix,
+      },
+      'prefix'
+    );
+  }
+
+  /**
+   * Returns a random name suffix.
+   *
+   * @example
+   * faker.name.suffix() // 'DDS'
+   */
+  suffix(): string {
+    // TODO @Shinigami92 2022-03-21: Add female_suffix and male_suffix
+    return this.faker.helpers.arrayElement(this.faker.definitions.name.suffix);
+  }
+
+  /**
+   * Generates a random job title.
+   *
+   * @example
+   * faker.name.title() // 'International Integration Manager'
+   *
+   * @deprecated
+   */
+  title(): string {
+    deprecated({
+      deprecated: 'faker.name.title()',
+      proposed: 'faker.name.jobTitle()',
+      since: 'v6.1.2',
+      until: 'v7.0.0',
+    });
+
+    return this.jobTitle();
+  }
+
+  /**
+   * Generates a random job title.
+   *
+   * @example
+   * faker.name.jobTitle() // 'Global Accounts Engineer'
+   */
+  jobTitle(): string {
+    return `${this.jobDescriptor()} ${this.jobArea()} ${this.jobType()}`;
+  }
+
+  /**
+   * Generates a random job descriptor.
+   *
+   * @example
+   * faker.name.jobDescriptor() // 'Customer'
+   */
+  jobDescriptor(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.name.title.descriptor
+    );
+  }
+
+  /**
+   * Generates a random job area.
+   *
+   * @example
+   * faker.name.jobArea() // 'Brand'
+   */
+  jobArea(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.name.title.level
+    );
+  }
+
+  /**
+   * Generates a random job type.
+   *
+   * @example
+   * faker.name.jobType() // 'Assistant'
+   */
+  jobType(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.name.title.job
+    );
+  }
+}
diff --git a/src/modules/phone/index.ts b/src/modules/phone/index.ts
new file mode 100644
index 00000000..7e85915c
--- /dev/null
+++ b/src/modules/phone/index.ts
@@ -0,0 +1,76 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate phone-related data.
+ */
+export class Phone {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Phone.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generates a random phone number.
+   *
+   * @param format Format of the phone number. Defaults to `faker.phone.phoneFormats()`.
+   *
+   * @example
+   * faker.phone.phoneNumber() // '961-770-7727'
+   * faker.phone.phoneNumber('501-###-###') // '501-039-841'
+   * faker.phone.phoneNumber('+48 91 ### ## ##') // '+48 91 463 61 70'
+   */
+  // TODO @pkuczynski 2022-02-01: simplify name to `number()`
+  phoneNumber(format?: string): string {
+    return this.faker.helpers.replaceSymbolWithNumber(
+      format || this.phoneFormats()
+    );
+  }
+
+  /**
+   * Returns phone number in a format of the given index from `faker.definitions.phone_number.formats`.
+   *
+   * @param phoneFormatsArrayIndex Index in the `faker.definitions.phone_number.formats` array. Defaults to `0`.
+   *
+   * @example
+   * faker.phone.phoneNumberFormat() // '943-627-0355'
+   * faker.phone.phoneNumberFormat(3) // '282.652.3201'
+   */
+  // FIXME @Shinigami 2022-01-14: this is strange passing in an array index
+  // TODO @pkuczynski 2022-02-01: discuss removing this method as it tightly couples with localisation
+  phoneNumberFormat(phoneFormatsArrayIndex = 0): string {
+    return this.faker.helpers.replaceSymbolWithNumber(
+      this.faker.definitions.phone_number.formats[phoneFormatsArrayIndex]
+    );
+  }
+
+  /**
+   * Returns a random phone number format.
+   *
+   * @example
+   * faker.phone.phoneFormats() // '!##.!##.####'
+   */
+  // TODO @pkuczynski 2022-02-01: simplify name to `format()`
+  phoneFormats(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.phone_number.formats
+    );
+  }
+
+  /**
+   * Generates IMEI number.
+   *
+   * @example
+   * faker.phone.imei() // '13-850175-913761-7'
+   */
+  imei(): string {
+    return this.faker.helpers.replaceCreditCardSymbols(
+      '##-######-######-L',
+      '#'
+    );
+  }
+}
diff --git a/src/modules/random/index.ts b/src/modules/random/index.ts
new file mode 100644
index 00000000..7939b298
--- /dev/null
+++ b/src/modules/random/index.ts
@@ -0,0 +1,648 @@
+import type { Faker } from '../..';
+import { FakerError } from '../../errors/faker-error';
+import { deprecated } from '../../internal/deprecated';
+
+/**
+ * Method to reduce array of characters.
+ *
+ * @param arr existing array of characters
+ * @param values array of characters which should be removed
+ * @returns new array without banned characters
+ */
+function arrayRemove<T>(arr: T[], values: readonly T[]): T[] {
+  values.forEach((value) => {
+    arr = arr.filter((ele) => ele !== value);
+  });
+  return arr;
+}
+
+/**
+ * Generates random values of different kinds. Some methods are deprecated and have been moved to dedicated modules.
+ */
+export class Random {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Random.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a single random number between zero and the given max value or the given range with the specified precision.
+   * The bounds are inclusive.
+   *
+   * @param options Maximum value or options object.
+   * @param options.min Lower bound for generated number. Defaults to `0`.
+   * @param options.max Upper bound for generated number. Defaults to `99999`.
+   * @param options.precision Precision of the generated number. Defaults to `1`.
+   *
+   * @see faker.datatype.number()
+   *
+   * @example
+   * faker.random.number() // 55422
+   * faker.random.number(100) // 52
+   * faker.random.number({ min: 1000000 }) // 431433
+   * faker.random.number({ max: 100 }) // 42
+   * faker.random.number({ precision: 0.01 }) // 64246.18
+   * faker.random.number({ min: 10, max: 100, precision: 0.01 }) // 36.94
+   *
+   * @deprecated
+   */
+  number(
+    options?: number | { min?: number; max?: number; precision?: number }
+  ): number {
+    deprecated({
+      deprecated: 'faker.random.number()',
+      proposed: 'faker.datatype.number()',
+      // since: 'v5.0.0', (?)
+      until: 'v7.0.0',
+    });
+    return this.faker.datatype.number(options);
+  }
+
+  /**
+   * Returns a single random floating-point number for the given precision or range and precision.
+   *
+   * @param options Precision or options object.
+   * @param options.min Lower bound for generated number. Defaults to `0`.
+   * @param options.max Upper bound for generated number. Defaults to `99999`.
+   * @param options.precision Precision of the generated number. Defaults to `0.01`.
+   *
+   * @see faker.datatype.float()
+   *
+   * @example
+   * faker.random.float() // 51696.36
+   * faker.random.float(0.1) // 52023.2
+   * faker.random.float({ min: 1000000 }) // 212859.76
+   * faker.random.float({ max: 100 }) // 28.11
+   * faker.random.float({ precision: 0.1 }) // 84055.3
+   * faker.random.float({ min: 10, max: 100, precision: 0.001 }) // 57.315
+   *
+   * @deprecated
+   */
+  float(
+    options?: number | { min?: number; max?: number; precision?: number }
+  ): number {
+    deprecated({
+      deprecated: 'faker.random.float()',
+      proposed: 'faker.datatype.float()',
+      // since: 'v5.0.0', (?)
+      until: 'v7.0.0',
+    });
+    return this.faker.datatype.float(options);
+  }
+
+  /**
+   * Returns random element from the given array.
+   *
+   * @template T The type of the entries to pick from.
+   * @param array Array to pick the value from. Defaults to `['a', 'b', 'c']`.
+   *
+   * @example
+   * faker.random.arrayElement() // 'b'
+   * faker.random.arrayElement(['cat', 'dog', 'mouse']) // 'dog'
+   *
+   * @deprecated
+   */
+  arrayElement<T = string>(
+    array: ReadonlyArray<T> = ['a', 'b', 'c'] as unknown as ReadonlyArray<T>
+  ): T {
+    deprecated({
+      deprecated: 'faker.random.arrayElement()',
+      proposed: 'faker.helpers.arrayElement()',
+      since: 'v6.3.0',
+      until: 'v7.0.0',
+    });
+    return this.faker.helpers.arrayElement(array);
+  }
+
+  /**
+   * Returns a subset with random elements of the given array in random order.
+   *
+   * @template T The type of the entries to pick from.
+   * @param array Array to pick the value from. Defaults to `['a', 'b', 'c']`.
+   * @param count Number of elements to pick.
+   *    When not provided, random number of elements will be picked.
+   *    When value exceeds array boundaries, it will be limited to stay inside.
+   *
+   * @example
+   * faker.random.arrayElements() // ['b', 'c']
+   * faker.random.arrayElements(['cat', 'dog', 'mouse']) // ['mouse', 'cat']
+   * faker.random.arrayElements([1, 2, 3, 4, 5], 2) // [4, 2]
+   *
+   * @deprecated
+   */
+  arrayElements<T>(
+    array: ReadonlyArray<T> = ['a', 'b', 'c'] as unknown as ReadonlyArray<T>,
+    count?: number
+  ): T[] {
+    deprecated({
+      deprecated: 'faker.random.arrayElements()',
+      proposed: 'faker.helpers.arrayElements()',
+      since: 'v6.3.0',
+      until: 'v7.0.0',
+    });
+    return this.faker.helpers.arrayElements(array, count);
+  }
+
+  /**
+   * Returns a random key from given object.
+   *
+   * @template T The type of `Record` to pick from.
+   * @template K The keys of `T`.
+   * @param object The object to get the keys from.
+   * @param field If this is set to `'key'`, this method will a return a random key of the given instance.
+   *
+   * @see faker.helpers.objectKey()
+   *
+   * @example
+   * const object = { keyA: 'valueA', keyB: 42 };
+   * faker.random.objectElement(object, 'key') // 'keyB'
+   *
+   * @deprecated
+   */
+  objectElement<T extends Record<string, unknown>, K extends keyof T>(
+    object: T,
+    field: 'key'
+  ): K;
+  /**
+   * Returns a random value from given object.
+   *
+   * @template T The type of `Record` to pick from.
+   * @template K The keys of `T`.
+   * @param object The object to get the values from.
+   * @param field If this is set to `'value'`, this method will a return a random value of the given instance.
+   *
+   * @see faker.helpers.objectValue()
+   *
+   * @example
+   * const object = { keyA: 'valueA', keyB: 42 };
+   * faker.random.objectElement(object) // 42
+   * faker.random.objectElement(object, 'value') // 'valueA'
+   *
+   * @deprecated
+   */
+  objectElement<T extends Record<string, unknown>, K extends keyof T>(
+    object: T,
+    field?: unknown
+  ): T[K];
+  /**
+   * Returns a random key or value from given object.
+   *
+   * @template T The type of `Record` to pick from.
+   * @template K The keys of `T`.
+   * @param object The object to get the keys or values from.
+   * @param field If this is set to `'key'`, this method will a return a random key of the given instance.
+   * If this is set to `'value'`, this method will a return a random value of the given instance.
+   * Defaults to `'value'`.
+   *
+   * @see faker.helpers.objectKey()
+   * @see faker.helpers.objectValue()
+   *
+   * @example
+   * const object = { keyA: 'valueA', keyB: 42 };
+   * faker.random.objectElement(object) // 42
+   * faker.random.objectElement(object, 'key') // 'keyB'
+   * faker.random.objectElement(object, 'value') // 'valueA'
+   *
+   * @deprecated
+   */
+  objectElement<T extends Record<string, unknown>, K extends keyof T>(
+    object?: T,
+    field?: 'key' | 'value'
+  ): K | T[K];
+  /**
+   * Returns a random key or value from given object.
+   *
+   * @template T The type of `Record` to pick from.
+   * @template K The keys of `T`.
+   * @param object The object to get the keys or values from.
+   * @param field If this is set to `'key'`, this method will a return a random key of the given instance.
+   * If this is set to `'value'`, this method will a return a random value of the given instance.
+   * Defaults to `'value'`.
+   *
+   * @see faker.helpers.objectKey()
+   * @see faker.helpers.objectValue()
+   *
+   * @example
+   * const object = { keyA: 'valueA', keyB: 42 };
+   * faker.random.objectElement(object) // 42
+   * faker.random.objectElement(object, 'key') // 'keyB'
+   * faker.random.objectElement(object, 'value') // 'valueA'
+   *
+   * @deprecated
+   */
+  objectElement<T extends Record<string, unknown>, K extends keyof T>(
+    object: T = { foo: 'bar', too: 'car' } as unknown as T,
+    field: 'key' | 'value' = 'value'
+  ): K | T[K] {
+    const useKey = field === 'key';
+    deprecated({
+      deprecated: `faker.random.objectElement(${useKey ? "obj, 'key'" : ''})`,
+      proposed: `faker.helpers.object${useKey ? 'Key' : 'Value'}()`,
+      since: 'v6.3.0',
+      until: 'v7.0.0',
+    });
+    return field === 'key'
+      ? (this.faker.helpers.objectKey(object) as K)
+      : (this.faker.helpers.objectValue(object) as T[K]);
+  }
+
+  /**
+   * Returns a UUID v4 ([Universally Unique Identifier](https://en.wikipedia.org/wiki/Universally_unique_identifier)).
+   *
+   * @see faker.datatype.uuid()
+   *
+   * @example
+   * faker.random.uuid() // '4136cd0b-d90b-4af7-b485-5d1ded8db252'
+   *
+   * @deprecated
+   */
+  uuid(): string {
+    deprecated({
+      deprecated: 'faker.random.uuid()',
+      proposed: 'faker.datatype.uuid()',
+      // since: 'v5.0.0', (?)
+      until: 'v7.0.0',
+    });
+    return this.faker.datatype.uuid();
+  }
+
+  /**
+   * Returns the boolean value `true` or `false`.
+   *
+   * @see faker.datatype.boolean()
+   *
+   * @example
+   * faker.random.boolean() // false
+   *
+   * @deprecated
+   */
+  boolean(): boolean {
+    deprecated({
+      deprecated: 'faker.random.boolean()',
+      proposed: 'faker.datatype.boolean()',
+      // since: 'v5.0.0', (?)
+      until: 'v7.0.0',
+    });
+    return this.faker.datatype.boolean();
+  }
+
+  /**
+   * Returns random word.
+   *
+   * @example
+   * faker.random.word() // 'Seamless'
+   */
+  word(): string {
+    const wordMethods = [
+      this.faker.commerce.department,
+      this.faker.commerce.productName,
+      this.faker.commerce.productAdjective,
+      this.faker.commerce.productMaterial,
+      this.faker.commerce.product,
+      this.faker.commerce.color,
+
+      this.faker.company.catchPhraseAdjective,
+      this.faker.company.catchPhraseDescriptor,
+      this.faker.company.catchPhraseNoun,
+      this.faker.company.bsAdjective,
+      this.faker.company.bsBuzz,
+      this.faker.company.bsNoun,
+      this.faker.address.streetSuffix,
+      this.faker.address.county,
+      this.faker.address.country,
+      this.faker.address.state,
+
+      this.faker.finance.accountName,
+      this.faker.finance.transactionType,
+      this.faker.finance.currencyName,
+
+      this.faker.hacker.noun,
+      this.faker.hacker.verb,
+      this.faker.hacker.adjective,
+      this.faker.hacker.ingverb,
+      this.faker.hacker.abbreviation,
+
+      this.faker.name.jobDescriptor,
+      this.faker.name.jobArea,
+      this.faker.name.jobType,
+    ];
+
+    const bannedChars = [
+      '!',
+      '#',
+      '%',
+      '&',
+      '*',
+      ')',
+      '(',
+      '+',
+      '=',
+      '.',
+      '<',
+      '>',
+      '{',
+      '}',
+      '[',
+      ']',
+      ':',
+      ';',
+      "'",
+      '"',
+      '_',
+      '-',
+    ];
+    let result: string;
+
+    do {
+      // randomly pick from the many faker methods that can generate words
+      const randomWordMethod = this.faker.helpers.arrayElement(wordMethods);
+
+      result = randomWordMethod();
+    } while (!result || bannedChars.some((char) => result.includes(char)));
+
+    return this.faker.helpers.arrayElement(result.split(' '));
+  }
+
+  /**
+   * Returns string with set of random words.
+   *
+   * @param count Number of words. Defaults to a random value between `1` and `3`.
+   *
+   * @example
+   * faker.random.words() // 'neural'
+   * faker.random.words(5) // 'copy Handcrafted bus client-server Point'
+   */
+  words(count?: number): string {
+    const words: string[] = [];
+
+    if (count == null) {
+      count = this.faker.datatype.number({ min: 1, max: 3 });
+    }
+
+    for (let i = 0; i < count; i++) {
+      words.push(this.word());
+    }
+
+    return words.join(' ');
+  }
+
+  /**
+   * Returns a random image url.
+   *
+   * @see faker.random.image()
+   *
+   * @example
+   * faker.random.image() // 'http://placeimg.com/640/480/animals'
+   *
+   * @deprecated
+   */
+  image(): string {
+    deprecated({
+      deprecated: 'faker.random.image()',
+      proposed: 'faker.image.image()',
+      // since: 'v5.0.0', (?)
+      until: 'v7.0.0',
+    });
+    return this.faker.image.image();
+  }
+
+  /**
+   * Returns a random locale, that is available in this faker instance.
+   * You can use the returned locale with `faker.setLocale(result)`.
+   *
+   * @example
+   * faker.random.locale() // 'el'
+   */
+  locale(): string {
+    return this.faker.helpers.arrayElement(Object.keys(this.faker.locales));
+  }
+
+  /**
+   * Generating a string consisting of lower/upper alpha characters based on count and upcase options.
+   *
+   * @param options Either the number of characters or an options instance. Defaults to `{ count: 1, upcase: false, bannedChars: [] }`.
+   * @param options.count The number of characters to generate. Defaults to `1`.
+   * @param options.upcase If true, the result will be uppercase. If false, it will be lowercase. Defaults to `false`.
+   * @param options.bannedChars An array with characters to exclude. Defaults to `[]`.
+   *
+   * @example
+   * faker.random.alpha() // 'b'
+   * faker.random.alpha(10) // 'qccrabobaf'
+   * faker.random.alpha({ count: 5, upcase: true, bannedChars: ['a'] }) // 'DTCIC'
+   */
+  // TODO @Shinigami92 2022-02-14: Tests covered `(count, options)`, but they were never typed like that
+  alpha(
+    options:
+      | number
+      | {
+          count?: number;
+          upcase?: boolean;
+          bannedChars?: readonly string[];
+        } = {}
+  ): string {
+    if (typeof options === 'number') {
+      options = {
+        count: options,
+      };
+    }
+    const { count = 1, upcase = false, bannedChars = [] } = options;
+
+    let charsArray = [
+      'a',
+      'b',
+      'c',
+      'd',
+      'e',
+      'f',
+      'g',
+      'h',
+      'i',
+      'j',
+      'k',
+      'l',
+      'm',
+      'n',
+      'o',
+      'p',
+      'q',
+      'r',
+      's',
+      't',
+      'u',
+      'v',
+      'w',
+      'x',
+      'y',
+      'z',
+    ];
+
+    charsArray = arrayRemove(charsArray, bannedChars);
+
+    let wholeString = '';
+    for (let i = 0; i < count; i++) {
+      wholeString += this.faker.helpers.arrayElement(charsArray);
+    }
+
+    return upcase ? wholeString.toUpperCase() : wholeString;
+  }
+
+  /**
+   * Generating a string consisting of lower/upper alpha characters and digits based on count and upcase options.
+   *
+   * @param count The number of characters and digits to generate. Defaults to `1`.
+   * @param options The options to use. Defaults to `{ bannedChars: [] }`.
+   * @param options.bannedChars An array of characters and digits which should be banned in the generated string. Defaults to `[]`.
+   *
+   * @example
+   * faker.random.alphaNumeric() // '2'
+   * faker.random.alphaNumeric(5) // '3e5v7'
+   * faker.random.alphaNumeric(5, { bannedChars: ["a"] }) // 'xszlm'
+   */
+  alphaNumeric(
+    count: number = 1,
+    options: { bannedChars?: readonly string[] } = {}
+  ): string {
+    const { bannedChars = [] } = options;
+
+    let charsArray = [
+      '0',
+      '1',
+      '2',
+      '3',
+      '4',
+      '5',
+      '6',
+      '7',
+      '8',
+      '9',
+      'a',
+      'b',
+      'c',
+      'd',
+      'e',
+      'f',
+      'g',
+      'h',
+      'i',
+      'j',
+      'k',
+      'l',
+      'm',
+      'n',
+      'o',
+      'p',
+      'q',
+      'r',
+      's',
+      't',
+      'u',
+      'v',
+      'w',
+      'x',
+      'y',
+      'z',
+    ];
+
+    charsArray = arrayRemove(charsArray, bannedChars);
+
+    if (charsArray.length === 0) {
+      throw new FakerError(
+        'Unable to generate string, because all possible characters are banned.'
+      );
+    }
+
+    let wholeString = '';
+    for (let i = 0; i < count; i++) {
+      wholeString += this.faker.helpers.arrayElement(charsArray);
+    }
+
+    return wholeString;
+  }
+
+  /**
+   * Generates a given length string of digits.
+   *
+   * @param length The number of digits to generate. Defaults to `1`.
+   * @param options The options to use. Defaults to `{}`.
+   * @param options.allowLeadingZeros If true, leading zeros will be allowed. Defaults to `false`.
+   * @param options.bannedDigits An array of digits which should be banned in the generated string. Defaults to `[]`.
+   *
+   * @example
+   * faker.random.numeric() // '2'
+   * faker.random.numeric(5) // '31507'
+   * faker.random.numeric(42) // '56434563150765416546479875435481513188548'
+   * faker.random.numeric(42, { allowLeadingZeros: true }) // '00564846278453876543517840713421451546115'
+   * faker.random.numeric(6, { bannedDigits: ['0'] }) // '943228'
+   */
+  numeric(
+    length: number = 1,
+    options: {
+      allowLeadingZeros?: boolean;
+      bannedDigits?: readonly string[];
+    } = {}
+  ): string {
+    if (length <= 0) {
+      return '';
+    }
+
+    const { allowLeadingZeros = false, bannedDigits = [] } = options;
+
+    const allowedDigits = '0123456789'
+      .split('')
+      .filter((digit) => !bannedDigits.includes(digit));
+
+    if (
+      allowedDigits.length === 0 ||
+      (allowedDigits.length === 1 &&
+        !allowLeadingZeros &&
+        allowedDigits[0] === '0')
+    ) {
+      throw new FakerError(
+        'Unable to generate numeric string, because all possible digits are banned.'
+      );
+    }
+
+    let result = '';
+
+    if (!allowLeadingZeros && !bannedDigits.includes('0')) {
+      result += this.faker.helpers.arrayElement(
+        allowedDigits.filter((digit) => digit !== '0')
+      );
+    }
+
+    while (result.length < length) {
+      result += this.faker.helpers.arrayElement(allowedDigits);
+    }
+
+    return result;
+  }
+
+  /**
+   * Returns a hexadecimal number.
+   *
+   * @param count Length of the generated number. Defaults to `1`.
+   *
+   * @see faker.datatype.hexadecimal()
+   *
+   * @example
+   * faker.random.hexaDecimal() // '0xb'
+   * faker.random.hexaDecimal(10) // '0xaE13F044fb'
+   *
+   * @deprecated
+   */
+  hexaDecimal(count?: number): string {
+    deprecated({
+      deprecated: 'faker.random.hexaDecimal()',
+      proposed: 'faker.datatype.hexadecimal()',
+      // since: 'v5.0.0', (?)
+      until: 'v7.0.0',
+    });
+
+    return this.faker.datatype.hexadecimal(count);
+  }
+}
diff --git a/src/modules/system/index.ts b/src/modules/system/index.ts
new file mode 100644
index 00000000..250f1fb8
--- /dev/null
+++ b/src/modules/system/index.ts
@@ -0,0 +1,194 @@
+import type { Faker } from '../..';
+
+const commonFileTypes = ['video', 'audio', 'image', 'text', 'application'];
+
+const commonMimeTypes = [
+  'application/pdf',
+  'audio/mpeg',
+  'audio/wav',
+  'image/png',
+  'image/jpeg',
+  'image/gif',
+  'video/mp4',
+  'video/mpeg',
+  'text/html',
+];
+
+/**
+ * Converts the given set to an array.
+ *
+ * @param set The set to convert.
+ */
+// TODO ST-DDT 2022-03-11: Replace with Array.from(Set)
+function setToArray<T>(set: Set<T>): T[] {
+  // shortcut if Array.from is available
+  if (Array.from) {
+    return Array.from(set);
+  }
+
+  const array: T[] = [];
+  set.forEach((item) => {
+    array.push(item);
+  });
+  return array;
+}
+
+/**
+ * Generates fake data for many computer systems properties.
+ */
+export class System {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(System.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a random file name with extension.
+   *
+   * @example
+   * faker.system.fileName() // 'self_enabling_accountability_toys.kpt'
+   */
+  fileName(): string {
+    const str = this.faker.random.words().toLowerCase().replace(/\W/g, '_');
+
+    return `${str}.${this.fileExt()}`;
+  }
+
+  /**
+   * Returns a random file name with a given extension or a commonly used extension.
+   *
+   * @param ext Extension. Empty string is considered to be not set.
+   * @example
+   * faker.system.commonFileName() // 'dollar.jpg'
+   * faker.system.commonFileName('txt') // 'global_borders_wyoming.txt'
+   */
+  commonFileName(ext?: string): string {
+    const str = this.faker.random.words().toLowerCase().replace(/\W/g, '_');
+
+    return `${str}.${ext || this.commonFileExt()}`;
+  }
+
+  /**
+   * Returns a mime-type.
+   *
+   * @example
+   * faker.system.mimeType() // 'video/vnd.vivo'
+   */
+  mimeType(): string {
+    const mimeTypeKeys = Object.keys(this.faker.definitions.system.mimeTypes);
+
+    return this.faker.helpers.arrayElement(mimeTypeKeys);
+  }
+
+  /**
+   * Returns a commonly used file type.
+   *
+   * @example
+   * faker.system.commonFileType() // 'audio'
+   */
+  commonFileType(): string {
+    return this.faker.helpers.arrayElement(commonFileTypes);
+  }
+
+  /**
+   * Returns a commonly used file extension.
+   *
+   * @example
+   * faker.system.commonFileExt() // 'gif'
+   */
+  commonFileExt(): string {
+    return this.fileExt(this.faker.helpers.arrayElement(commonMimeTypes));
+  }
+
+  /**
+   * Returns a file type.
+   *
+   * @example
+   * faker.system.fileType() // 'message'
+   */
+  fileType(): string {
+    const typeSet = new Set<string>();
+    const mimeTypes = this.faker.definitions.system.mimeTypes;
+
+    Object.keys(mimeTypes).forEach((m) => {
+      const type = m.split('/')[0];
+
+      typeSet.add(type);
+    });
+
+    const types = setToArray(typeSet);
+    return this.faker.helpers.arrayElement(types);
+  }
+
+  /**
+   * Returns a file extension.
+   *
+   * @param mimeType Valid [mime-type](https://github.com/jshttp/mime-db/blob/master/db.json)
+   *
+   * @example
+   * faker.system.fileExt() // 'emf'
+   * faker.system.fileExt('application/json') // 'json'
+   */
+  fileExt(mimeType?: string): string {
+    if (typeof mimeType === 'string') {
+      const mimes = this.faker.definitions.system.mimeTypes;
+      return this.faker.helpers.arrayElement(mimes[mimeType].extensions);
+    }
+
+    const mimeTypes = this.faker.definitions.system.mimeTypes;
+    const extensionSet = new Set<string>();
+
+    Object.keys(mimeTypes).forEach((m) => {
+      if (mimeTypes[m].extensions instanceof Array) {
+        mimeTypes[m].extensions.forEach((ext) => {
+          extensionSet.add(ext);
+        });
+      }
+    });
+
+    const extensions = setToArray(extensionSet);
+
+    return this.faker.helpers.arrayElement(extensions);
+  }
+
+  /**
+   * Returns a directory path.
+   *
+   * @example
+   * faker.system.directoryPath() // '/etc/mail'
+   */
+  directoryPath(): string {
+    const paths = this.faker.definitions.system.directoryPaths;
+    return this.faker.helpers.arrayElement(paths);
+  }
+
+  /**
+   * Returns a file path.
+   *
+   * @example
+   * faker.system.filePath() // '/usr/local/src/money.dotx'
+   */
+  // TODO @prisis 2022-01-25: add a parameter to have the possibility to have one or two ext on file.
+  filePath(): string {
+    return `${this.directoryPath()}/${this.fileName()}`;
+  }
+
+  /**
+   * Returns a [semantic version](https://semver.org).
+   *
+   * @example
+   * faker.system.semver() // '1.1.2'
+   */
+  semver(): string {
+    return [
+      this.faker.datatype.number(9),
+      this.faker.datatype.number(9),
+      this.faker.datatype.number(9),
+    ].join('.');
+  }
+}
diff --git a/src/modules/time/index.ts b/src/modules/time/index.ts
new file mode 100644
index 00000000..021d75c8
--- /dev/null
+++ b/src/modules/time/index.ts
@@ -0,0 +1,57 @@
+import { deprecated } from '../../internal/deprecated';
+import type { LiteralUnion } from '../../utils/types';
+
+/**
+ * Module to generate time of dates in various formats.
+ *
+ * @deprecated You should stop using this module, as it will be removed in the future.
+ */
+export class Time {
+  /**
+   * Returns recent time.
+   *
+   * @param format The format to use.
+   *
+   * - `'abbr'` Return a string with only the time. `Date.toLocaleTimeString`.
+   * - `'date'` Return a date instance.
+   * - `'wide'` Return a string with a long time. `Date.toTimeString()`.
+   * - `'unix'` Returns a unix timestamp.
+   *
+   * Defaults to `'unix'`.
+   *
+   * @example
+   * faker.time.recent() // 1643067231856
+   * faker.time.recent('abbr') // '12:34:07 AM'
+   * faker.time.recent('date') // 2022-03-01T20:35:47.402Z
+   * faker.time.recent('wide') // '00:34:11 GMT+0100 (Central European Standard Time)'
+   * faker.time.recent('unix') // 1643067231856
+   *
+   * @deprecated You should stop using this function, as it will be removed in the future. Use the native `new Date()` with one of the wanted functions directly.
+   */
+  recent(
+    format: LiteralUnion<'abbr' | 'date' | 'wide' | 'unix'> = 'unix'
+  ): string | number | Date {
+    deprecated({
+      deprecated: 'faker.time.recent()',
+      proposed: 'native `new Date()` and call the function you want on it',
+      since: 'v6.1.0',
+      until: 'v7.0.0',
+    });
+
+    let date: string | number | Date = new Date();
+
+    switch (format) {
+      case 'abbr':
+        date = date.toLocaleTimeString();
+        break;
+      case 'wide':
+        date = date.toTimeString();
+        break;
+      case 'unix':
+        date = date.getTime();
+        break;
+    }
+
+    return date;
+  }
+}
diff --git a/src/modules/unique/index.ts b/src/modules/unique/index.ts
new file mode 100644
index 00000000..798fc29e
--- /dev/null
+++ b/src/modules/unique/index.ts
@@ -0,0 +1,139 @@
+import { deprecated } from '../../internal/deprecated';
+import type { RecordKey } from './unique';
+import * as uniqueExec from './unique';
+
+/**
+ * Module to generate unique entries.
+ */
+export class Unique {
+  /**
+   * Maximum time `unique.exec` will attempt to run before aborting.
+   *
+   * @deprecated Use options instead.
+   */
+  private _maxTime = 10;
+
+  /**
+   * Maximum time `unique.exec` will attempt to run before aborting.
+   *
+   * @deprecated Use options instead.
+   */
+  get maxTime(): number {
+    deprecated({
+      deprecated: 'faker.unique.maxTime',
+      proposed: 'Options',
+      since: 'v6.2.0',
+      until: 'v7.0.0',
+    });
+    return this._maxTime;
+  }
+
+  /**
+   * Maximum time `unique.exec` will attempt to run before aborting.
+   *
+   * @deprecated Use options instead.
+   */
+  set maxTime(value: number) {
+    deprecated({
+      deprecated: 'faker.unique.maxTime',
+      proposed: 'Options',
+      since: 'v6.2.0',
+      until: 'v7.0.0',
+    });
+    this._maxTime = value;
+  }
+
+  /**
+   * Maximum retries `unique.exec` will recurse before aborting (max loop depth).
+   *
+   * @deprecated Use options instead.
+   */
+  private _maxRetries = 10;
+
+  /**
+   * Maximum retries `unique.exec` will recurse before aborting (max loop depth).
+   *
+   * @deprecated Use options instead.
+   */
+  get maxRetries(): number {
+    deprecated({
+      deprecated: 'faker.unique.maxRetries',
+      proposed: 'Options',
+      since: 'v6.2.0',
+      until: 'v7.0.0',
+    });
+    return this._maxRetries;
+  }
+
+  /**
+   * Maximum retries `unique.exec` will recurse before aborting (max loop depth).
+   *
+   * @deprecated Use options instead.
+   */
+  set maxRetries(value: number) {
+    deprecated({
+      deprecated: 'faker.unique.maxRetries',
+      proposed: 'Options',
+      since: 'v6.2.0',
+      until: 'v7.0.0',
+    });
+    this._maxRetries = value;
+  }
+
+  constructor() {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Unique.prototype)) {
+      if (
+        name === 'constructor' ||
+        name === 'maxTime' ||
+        name === 'maxRetries' ||
+        typeof this[name] !== 'function'
+      ) {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Generates a unique result using the results of the given method.
+   * Used unique entries will be stored internally and filtered from subsequent calls.
+   *
+   * @template Method The type of the method to execute.
+   * @param method The method used to generate the values.
+   * @param args The arguments used to call the method.
+   * @param options The optional options used to configure this method.
+   * @param options.startTime This parameter does nothing.
+   * @param options.maxTime The time in milliseconds this method may take before throwing an error. Defaults to `50`.
+   * @param options.maxRetries The total number of attempts to try before throwing an error. Defaults to `50`.
+   * @param options.currentIterations This parameter does nothing.
+   * @param options.exclude The value or values that should be excluded/skipped. Defaults to `[]`.
+   * @param options.compare The function used to determine whether a value was already returned. Defaults to check the existence of the key.
+   * @param options.store The store of unique entries. Defaults to a global store.
+   *
+   * @example
+   * faker.unique(faker.name.firstName) // 'Corbin'
+   */
+  unique<Method extends (...parameters) => RecordKey>(
+    method: Method,
+    args?: Parameters<Method>,
+    options: {
+      startTime?: number;
+      maxTime?: number;
+      maxRetries?: number;
+      currentIterations?: number;
+      exclude?: RecordKey | RecordKey[];
+      compare?: (obj: Record<RecordKey, RecordKey>, key: RecordKey) => 0 | -1;
+      store?: Record<RecordKey, RecordKey>;
+    } = {}
+  ): ReturnType<Method> {
+    const { maxTime = this._maxTime, maxRetries = this._maxRetries } = options;
+    return uniqueExec.exec(method, args, {
+      ...options,
+      startTime: new Date().getTime(),
+      maxTime,
+      maxRetries,
+      currentIterations: 0,
+    });
+  }
+}
diff --git a/src/modules/unique/unique.ts b/src/modules/unique/unique.ts
new file mode 100644
index 00000000..70408faf
--- /dev/null
+++ b/src/modules/unique/unique.ts
@@ -0,0 +1,158 @@
+import { FakerError } from '../../errors/faker-error';
+
+export type RecordKey = string | number | symbol;
+
+/**
+ * Global store of unique values.
+ * This means that faker should *never* return duplicate values across all API methods when using `Faker.unique` without passing `options.store`.
+ */
+const GLOBAL_UNIQUE_STORE: Record<RecordKey, RecordKey> = {};
+
+/**
+ * Global exclude list of results.
+ * Defaults to nothing excluded.
+ */
+const GLOBAL_UNIQUE_EXCLUDE: RecordKey[] = [];
+
+/**
+ * Uniqueness compare function.
+ * Default behavior is to check value as key against object hash.
+ *
+ * @param obj The object to check.
+ * @param key The key to check.
+ */
+function defaultCompare(
+  obj: Record<RecordKey, RecordKey>,
+  key: RecordKey
+): 0 | -1 {
+  if (obj[key] === undefined) {
+    return -1;
+  }
+  return 0;
+}
+
+/**
+ * Logs the given code as an error and throws it.
+ * Also logs a message for helping the user.
+ *
+ * @param startTime The time the execution started.
+ * @param now The current time.
+ * @param code The error code.
+ * @param store The store of unique entries.
+ * @param currentIterations Current iteration or retries of `unique.exec` (current loop depth).
+ *
+ * @throws The given error code with additional text.
+ */
+function errorMessage(
+  startTime: number,
+  now: number,
+  code: string,
+  store: Record<RecordKey, RecordKey>,
+  currentIterations: number
+): never {
+  console.error('Error', code);
+  console.log(
+    `Found ${Object.keys(store).length} unique entries before throwing error.
+retried: ${currentIterations}
+total time: ${now - startTime}ms`
+  );
+  throw new FakerError(
+    `${code} for uniqueness check.
+
+May not be able to generate any more unique values with current settings.
+Try adjusting maxTime or maxRetries parameters for faker.unique().`
+  );
+}
+
+/**
+ * Generates a unique result using the results of the given method.
+ * Used unique entries will be stored internally and filtered from subsequent calls.
+ *
+ * @template Method The type of the method to execute.
+ * @param method The method used to generate the values.
+ * @param args The arguments used to call the method.
+ * @param options The optional options used to configure this method.
+ * @param options.startTime The time this execution stared. Defaults to `new Date().getTime()`.
+ * @param options.maxTime The time in milliseconds this method may take before throwing an error. Defaults to `50`.
+ * @param options.maxRetries The total number of attempts to try before throwing an error. Defaults to `50`.
+ * @param options.currentIterations The current attempt. Defaults to `0`.
+ * @param options.exclude The value or values that should be excluded/skipped. Defaults to `[]`.
+ * @param options.compare The function used to determine whether a value was already returned. Defaults to check the existence of the key.
+ * @param options.store The store of unique entries. Defaults to `GLOBAL_UNIQUE_STORE`.
+ */
+export function exec<Method extends (...parameters) => RecordKey>(
+  method: Method,
+  args: Parameters<Method>,
+  options: {
+    startTime?: number;
+    maxTime?: number;
+    maxRetries?: number;
+    currentIterations?: number;
+    exclude?: RecordKey | RecordKey[];
+    compare?: (obj: Record<RecordKey, RecordKey>, key: RecordKey) => 0 | -1;
+    store?: Record<RecordKey, RecordKey>;
+  } = {}
+): ReturnType<Method> {
+  const now = new Date().getTime();
+
+  const {
+    startTime = new Date().getTime(),
+    maxTime = 50,
+    maxRetries = 50,
+    compare = defaultCompare,
+    store = GLOBAL_UNIQUE_STORE,
+  } = options;
+  let { exclude = GLOBAL_UNIQUE_EXCLUDE } = options;
+  options.currentIterations = options.currentIterations ?? 0;
+
+  // Support single exclude argument as string
+  if (!Array.isArray(exclude)) {
+    exclude = [exclude];
+  }
+
+  // if (options.currentIterations > 0) {
+  //   console.log('iterating', options.currentIterations)
+  // }
+
+  // console.log(now - startTime)
+  if (now - startTime >= maxTime) {
+    return errorMessage(
+      startTime,
+      now,
+      `Exceeded maxTime: ${maxTime}`,
+      store,
+      options.currentIterations
+    );
+  }
+
+  if (options.currentIterations >= maxRetries) {
+    return errorMessage(
+      startTime,
+      now,
+      `Exceeded maxRetries: ${maxRetries}`,
+      store,
+      options.currentIterations
+    );
+  }
+
+  // Execute the provided method to find a potential satisfied value.
+  const result: ReturnType<Method> = method.apply(this, args);
+
+  // If the result has not been previously found, add it to the found array and return the value as it's unique.
+  if (compare(store, result) === -1 && exclude.indexOf(result) === -1) {
+    store[result] = result;
+    options.currentIterations = 0;
+    return result;
+  } else {
+    // console.log('conflict', result);
+    options.currentIterations++;
+    return exec(method, args, {
+      ...options,
+      startTime,
+      maxTime,
+      maxRetries,
+      compare,
+      exclude,
+    });
+  }
+}
diff --git a/src/modules/vehicle/index.ts b/src/modules/vehicle/index.ts
new file mode 100644
index 00000000..ec010af9
--- /dev/null
+++ b/src/modules/vehicle/index.ts
@@ -0,0 +1,131 @@
+import type { Faker } from '../..';
+
+/**
+ * Module to generate vehicle related entries.
+ */
+export class Vehicle {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Vehicle.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns a random vehicle.
+   *
+   * @example
+   * faker.vehicle.vehicle() // 'BMW Explorer'
+   */
+  vehicle(): string {
+    return `${this.manufacturer()} ${this.model()}`;
+  }
+
+  /**
+   * Returns a manufacturer name.
+   *
+   * @example
+   * faker.vehicle.manufacturer() // 'Ford'
+   */
+  manufacturer(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.vehicle.manufacturer
+    );
+  }
+
+  /**
+   * Returns a vehicle model.
+   *
+   * @example
+   * faker.vehicle.model() // 'Explorer'
+   */
+  model(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.vehicle.model
+    );
+  }
+
+  /**
+   * Returns a vehicle type.
+   *
+   * @example
+   * faker.vehicle.type() // 'Coupe'
+   */
+  type(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.vehicle.type);
+  }
+
+  /**
+   * Returns a fuel type.
+   *
+   * @example
+   * faker.vehicle.fuel() // 'Electric'
+   */
+  fuel(): string {
+    return this.faker.helpers.arrayElement(this.faker.definitions.vehicle.fuel);
+  }
+
+  /**
+   * Returns a vehicle identification number (VIN).
+   *
+   * @example
+   * faker.vehicle.vin() // 'YV1MH682762184654'
+   */
+  vin(): string {
+    const bannedChars = ['o', 'i', 'q'];
+    return `${this.faker.random.alphaNumeric(10, {
+      bannedChars,
+    })}${this.faker.random.alpha({
+      count: 1,
+      upcase: true,
+      bannedChars,
+    })}${this.faker.random.alphaNumeric(1, {
+      bannedChars,
+    })}${this.faker.datatype.number({ min: 10000, max: 99999 })}` // return five digit #
+      .toUpperCase();
+  }
+
+  /**
+   * Returns a vehicle color.
+   *
+   * @example
+   * faker.vehicle.color() // 'red'
+   */
+  color(): string {
+    return this.faker.commerce.color();
+  }
+
+  /**
+   * Returns a vehicle registration number (Vehicle Registration Mark - VRM)
+   *
+   * @example
+   * faker.vehicle.vrm() // 'MF56UPA'
+   */
+  vrm(): string {
+    return `${this.faker.random.alpha({
+      count: 2,
+      upcase: true,
+    })}${this.faker.datatype.number({
+      min: 0,
+      max: 9,
+    })}${this.faker.datatype.number({
+      min: 0,
+      max: 9,
+    })}${this.faker.random.alpha({ count: 3, upcase: true })}`.toUpperCase();
+  }
+
+  /**
+   * Returns a type of bicycle.
+   *
+   * @example
+   * faker.vehicle.bicycle() // 'Adventure Road Bicycle'
+   */
+  bicycle(): string {
+    return this.faker.helpers.arrayElement(
+      this.faker.definitions.vehicle.bicycle_type
+    );
+  }
+}
diff --git a/src/modules/word/index.ts b/src/modules/word/index.ts
new file mode 100644
index 00000000..5968d225
--- /dev/null
+++ b/src/modules/word/index.ts
@@ -0,0 +1,174 @@
+import type { Faker } from '../..';
+
+/**
+ * Filters a string array for values with a specific length.
+ * If length is not provided or no values with this length there found a copy of the original array is returned.
+ *
+ * @param options The options to provide
+ * @param options.wordList A list of word to filter
+ * @param options.length The exact length words should have
+ */
+function filterWordListByLength(options: {
+  wordList: string[];
+  length?: number;
+}): string[] {
+  if (!options.length) {
+    return options.wordList;
+  }
+
+  const wordListWithLengthFilter = options.wordList.filter(
+    (word) => word.length === options.length
+  );
+
+  return wordListWithLengthFilter.length > 0
+    ? wordListWithLengthFilter
+    : [...options.wordList];
+}
+
+/**
+ * Module to return various types of words.
+ */
+export class Word {
+  constructor(private readonly faker: Faker) {
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(Word.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
+
+  /**
+   * Returns an adjective of random or optionally specified length.
+   *
+   * @param length Expected adjective length. If specified length is unresolvable, returns adjective of a random length.
+   *
+   * @example
+   * faker.word.adjective() // 'pungent'
+   * faker.word.adjective(5) // 'slimy'
+   * faker.word.adjective(100) // 'complete'
+   */
+  adjective(length?: number): string {
+    return this.faker.helpers.arrayElement(
+      filterWordListByLength({
+        wordList: this.faker.definitions.word.adjective,
+        length,
+      })
+    );
+  }
+
+  /**
+   * Returns an adverb of random or optionally specified length.
+   *
+   * @param length Expected adverb length. If specified length is unresolvable, returns adverb of a random length.
+   *
+   * @example
+   * faker.word.adverb() // 'quarrelsomely'
+   * faker.word.adverb(5) // 'madly'
+   * faker.word.adverb(100) // 'sadly'
+   */
+  adverb(length?: number): string {
+    return this.faker.helpers.arrayElement(
+      filterWordListByLength({
+        wordList: this.faker.definitions.word.adverb,
+        length,
+      })
+    );
+  }
+
+  /**
+   * Returns a conjunction of random or optionally specified length.
+   *
+   * @param length Expected conjunction length. If specified length is unresolvable, returns conjunction of a random length.
+   *
+   * @example
+   * faker.word.conjunction() // 'in order that'
+   * faker.word.conjunction(5) // 'since'
+   * faker.word.conjunction(100) // 'as long as'
+   */
+  conjunction(length?: number): string {
+    return this.faker.helpers.arrayElement(
+      filterWordListByLength({
+        wordList: this.faker.definitions.word.conjunction,
+        length,
+      })
+    );
+  }
+
+  /**
+   * Returns an interjection of random or optionally specified length.
+   *
+   * @param length Expected interjection length. If specified length is unresolvable, returns interjection of a random length.
+   *
+   * @example
+   * faker.word.interjection() // 'gah'
+   * faker.word.interjection(5) // 'fooey'
+   * faker.word.interjection(100) // 'yowza'
+   */
+  interjection(length?: number): string {
+    return this.faker.helpers.arrayElement(
+      filterWordListByLength({
+        wordList: this.faker.definitions.word.interjection,
+        length,
+      })
+    );
+  }
+
+  /**
+   * Returns a noun of random or optionally specified length.
+   *
+   * @param length Expected noun length. If specified length is unresolvable, returns noun of a random length.
+   *
+   * @example
+   * faker.word.noun() // 'external'
+   * faker.word.noun(5) // 'front'
+   * faker.word.noun(100) // 'care'
+   */
+  noun(length?: number): string {
+    return this.faker.helpers.arrayElement(
+      filterWordListByLength({
+        wordList: this.faker.definitions.word.noun,
+        length,
+      })
+    );
+  }
+
+  /**
+   * Returns a preposition of random or optionally specified length.
+   *
+   * @param length Expected preposition length. If specified length is unresolvable, returns preposition of a random length.
+   *
+   * @example
+   * faker.word.preposition() // 'without'
+   * faker.word.preposition(5) // 'abaft'
+   * faker.word.preposition(100) // 'an'
+   */
+  preposition(length?: number): string {
+    return this.faker.helpers.arrayElement(
+      filterWordListByLength({
+        wordList: this.faker.definitions.word.preposition,
+        length,
+      })
+    );
+  }
+
+  /**
+   * Returns a verb of random or optionally specified length.
+   *
+   * @param length Expected verb length. If specified length is unresolvable, returns verb of a random length.
+   *
+   * @example
+   * faker.word.verb() // 'act'
+   * faker.word.verb(5) // 'tinge'
+   * faker.word.verb(100) // 'mess'
+   */
+  verb(length?: number): string {
+    return this.faker.helpers.arrayElement(
+      filterWordListByLength({
+        wordList: this.faker.definitions.word.verb,
+        length,
+      })
+    );
+  }
+}