refactor(random)!: remove deprecated random module (#2678)

8 files changed, 14 insertions, 850 deletions

diff --git a/docs/.vitepress/api-pages.ts b/docs/.vitepress/api-pages.ts
index 60cd553d..7df42281 100644
--- a/docs/.vitepress/api-pages.ts
+++ b/docs/.vitepress/api-pages.ts
@@ -30,7 +30,6 @@ export const apiPages = [
       { text: 'Number', link: '/api/number.html' },
       { text: 'Person', link: '/api/person.html' },
       { text: 'Phone', link: '/api/phone.html' },
-      { text: 'Random', link: '/api/random.html' },
       { text: 'Science', link: '/api/science.html' },
       { text: 'String', link: '/api/string.html' },
       { text: 'System', link: '/api/system.html' },
diff --git a/docs/guide/upgrading_v9/2678.md b/docs/guide/upgrading_v9/2678.md
new file mode 100644
index 00000000..ce34e1f7
--- /dev/null
+++ b/docs/guide/upgrading_v9/2678.md
@@ -0,0 +1,12 @@
+### Remove deprecated random module
+
+Removed deprecated random module
+
+| old                           | replacement                                     |
+| ----------------------------- | ----------------------------------------------- |
+| `faker.random.alpha()`        | `faker.string.alpha()`                          |
+| `faker.random.alphaNumeric()` | `faker.string.alphanumeric()`                   |
+| `faker.random.locale()`       | `faker.helpers.objectKey(allLocales/allFakers)` |
+| `faker.random.numeric()`      | `faker.string.numeric()`                        |
+| `faker.random.word()`         | `faker.lorem.word()` or `faker.word.sample()`   |
+| `faker.random.words()`        | `faker.lorem.words()` or `faker.word.words()`   |
diff --git a/src/faker.ts b/src/faker.ts
index dbced02e..c78fe1de 100644
--- a/src/faker.ts
+++ b/src/faker.ts
@@ -24,7 +24,6 @@ import { MusicModule } from './modules/music';
 import type { PersonModule as NameModule } from './modules/person';
 import { PersonModule } from './modules/person';
 import { PhoneModule } from './modules/phone';
-import { RandomModule } from './modules/random';
 import { ScienceModule } from './modules/science';
 import { SystemModule } from './modules/system';
 import { VehicleModule } from './modules/vehicle';
@@ -62,12 +61,6 @@ export class Faker extends SimpleFaker {
   readonly rawDefinitions: LocaleDefinition;
   readonly definitions: LocaleProxy;
 
-  /**
-   * @deprecated Use the modules specific to the type of data you want to generate instead.
-   */
-  // eslint-disable-next-line deprecation/deprecation
-  readonly random: RandomModule = new RandomModule(this);
-
   readonly airline: AirlineModule = new AirlineModule(this);
   readonly animal: AnimalModule = new AnimalModule(this);
   readonly color: ColorModule = new ColorModule(this);
diff --git a/src/index.ts b/src/index.ts
index 8dd2982b..1edb01f9 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -124,8 +124,6 @@ export type {
   SexType,
 } from './modules/person';
 export type { PhoneModule } from './modules/phone';
-// eslint-disable-next-line deprecation/deprecation
-export type { RandomModule } from './modules/random';
 export type { ChemicalElement, ScienceModule, Unit } from './modules/science';
 export type { StringModule } from './modules/string';
 export type { SystemModule } from './modules/system';
diff --git a/src/modules/random/index.ts b/src/modules/random/index.ts
deleted file mode 100644
index 371c810e..00000000
--- a/src/modules/random/index.ts
+++ /dev/null
@@ -1,374 +0,0 @@
-import { FakerError } from '../../errors/faker-error';
-import { deprecated } from '../../internal/deprecated';
-import { ModuleBase } from '../../internal/module-base';
-import type { LiteralUnion } from '../../utils/types';
-import type {
-  AlphaChar,
-  AlphaNumericChar,
-  Casing,
-  NumericChar,
-} from '../string';
-
-/**
- * Generates random values of different kinds.
- *
- * @deprecated Use the modules specific to the type of data you want to generate instead.
- */
-export class RandomModule extends ModuleBase {
-  /**
-   * Returns a random word.
-   *
-   * @see faker.lorem.word(): For generating a random placeholder word.
-   * @see faker.word.sample(): For generating a random real word.
-   *
-   * @example
-   * faker.random.word() // 'Seamless'
-   *
-   * @since 3.1.0
-   *
-   * @deprecated Use `faker.lorem.word()` or `faker.word.sample()` instead.
-   */
-  word(): string {
-    deprecated({
-      deprecated: 'faker.random.word()',
-      proposed: 'faker.lorem.word() or faker.word.sample()',
-      since: '8.0',
-      until: '9.0',
-    });
-
-    const wordMethods = [
-      () => this.faker.location.cardinalDirection(),
-      this.faker.location.country,
-      this.faker.location.county,
-      () => this.faker.location.direction(),
-      () => this.faker.location.ordinalDirection(),
-      this.faker.location.state,
-      this.faker.location.street,
-
-      this.faker.color.human,
-
-      this.faker.commerce.department,
-      this.faker.commerce.product,
-      this.faker.commerce.productAdjective,
-      this.faker.commerce.productMaterial,
-      this.faker.commerce.productName,
-
-      this.faker.company.buzzAdjective,
-      this.faker.company.buzzNoun,
-      this.faker.company.buzzVerb,
-      this.faker.company.catchPhraseAdjective,
-      this.faker.company.catchPhraseDescriptor,
-      this.faker.company.catchPhraseNoun,
-
-      this.faker.finance.accountName,
-      this.faker.finance.currencyName,
-      this.faker.finance.transactionType,
-
-      this.faker.hacker.abbreviation,
-      this.faker.hacker.adjective,
-      this.faker.hacker.ingverb,
-      this.faker.hacker.noun,
-      this.faker.hacker.verb,
-
-      this.faker.lorem.word,
-
-      this.faker.music.genre,
-
-      this.faker.person.gender,
-      this.faker.person.jobArea,
-      this.faker.person.jobDescriptor,
-      this.faker.person.jobTitle,
-      this.faker.person.jobType,
-      this.faker.person.sex,
-
-      () => this.faker.science.chemicalElement().name,
-      () => this.faker.science.unit().name,
-
-      this.faker.vehicle.bicycle,
-      this.faker.vehicle.color,
-      this.faker.vehicle.fuel,
-      this.faker.vehicle.manufacturer,
-      this.faker.vehicle.type,
-
-      this.faker.word.adjective,
-      this.faker.word.adverb,
-      this.faker.word.conjunction,
-      this.faker.word.interjection,
-      this.faker.word.noun,
-      this.faker.word.preposition,
-      this.faker.word.verb,
-    ];
-
-    const bannedChars = [
-      '!',
-      '#',
-      '%',
-      '&',
-      '*',
-      ')',
-      '(',
-      '+',
-      '=',
-      '.',
-      '<',
-      '>',
-      '{',
-      '}',
-      '[',
-      ']',
-      ':',
-      ';',
-      "'",
-      '"',
-      '_',
-      '-',
-    ];
-    let result = '';
-
-    let iteration = 0;
-
-    do {
-      // randomly pick from the many faker methods that can generate words
-      const randomWordMethod = this.faker.helpers.arrayElement(wordMethods);
-
-      try {
-        result = randomWordMethod();
-      } catch {
-        // catch missing locale data potentially required by randomWordMethod
-        iteration++;
-
-        if (iteration > 100) {
-          throw new FakerError(
-            'No matching word data available for the current locale'
-          );
-        }
-
-        continue;
-      }
-    } while (!result || bannedChars.some((char) => result.includes(char)));
-
-    return this.faker.helpers.arrayElement(result.split(' '));
-  }
-
-  /**
-   * Returns a string with a given number of random words.
-   *
-   * @param count The number or range of words. Defaults to a random value between `1` and `3`.
-   * @param count.min The minimum number of words. Defaults to `1`.
-   * @param count.max The maximum number of words. Defaults to `3`.
-   *
-   * @see faker.lorem.words(): For generating a sequence of random placeholder words.
-   * @see faker.word.words(): For generating a sequence of random real words.
-   *
-   * @example
-   * faker.random.words() // 'neural'
-   * faker.random.words(5) // 'copy Handcrafted bus client-server Point'
-   * faker.random.words({ min: 3, max: 5 }) // 'cool sticky Borders'
-   *
-   * @since 3.1.0
-   *
-   * @deprecated Use `faker.lorem.words()` or `faker.word.words()` instead.
-   */
-  words(
-    count:
-      | number
-      | {
-          /**
-           * The minimum number of words.
-           */
-          min: number;
-          /**
-           * The maximum number of words.
-           */
-          max: number;
-        } = { min: 1, max: 3 }
-  ): string {
-    deprecated({
-      deprecated: 'faker.random.words()',
-      proposed: 'faker.lorem.words() or faker.word.words()',
-      since: '8.0',
-      until: '9.0',
-    });
-
-    // eslint-disable-next-line deprecation/deprecation
-    return this.faker.helpers.multiple(this.word, { count }).join(' ');
-  }
-
-  /**
-   * Do NOT use. This property has been removed.
-   *
-   * @example
-   * faker.helpers.objectKey(allLocales)
-   * faker.helpers.objectValue(allFakers)
-   *
-   * @since 3.1.0
-   *
-   * @deprecated Use `faker.helpers.objectKey(allLocales/allFakers)` instead.
-   */
-  private locale(): never {
-    // We cannot invoke this ourselves, because this would link to all locale data and increase the bundle size by a lot.
-    throw new FakerError(
-      'This method has been removed. Please use `faker.helpers.objectKey(allLocales/allFakers)` instead.'
-    );
-  }
-
-  /**
-   * Generating a string consisting of letters in the English alphabet.
-   *
-   * @param options Either the number of characters or an options instance.
-   * @param options.count The number of characters to generate. Defaults to `1`.
-   * @param options.casing The casing of the characters. Defaults to `'mixed'`.
-   * @param options.bannedChars An array with characters to exclude. Defaults to `[]`.
-   *
-   * @see faker.string.alpha(): For the replacement method.
-   *
-   * @example
-   * faker.random.alpha() // 'b'
-   * faker.random.alpha(10) // 'qccrabobaf'
-   * faker.random.alpha({ count: 5, casing: 'upper', bannedChars: ['A'] }) // 'DTCIC'
-   *
-   * @since 5.0.0
-   *
-   * @deprecated Use `faker.string.alpha()` instead.
-   */
-  alpha(
-    options:
-      | number
-      | {
-          /**
-           * The number of characters to generate.
-           *
-           * @default 1
-           */
-          count?: number;
-          /**
-           * The casing of the characters.
-           *
-           * @default 'mixed'
-           */
-          casing?: Casing;
-          /**
-           * An array with characters to exclude.
-           *
-           * @default []
-           */
-          bannedChars?: ReadonlyArray<LiteralUnion<AlphaChar>> | string;
-        } = {}
-  ): string {
-    deprecated({
-      deprecated: 'faker.random.alpha()',
-      proposed: 'faker.string.alpha()',
-      since: '8.0',
-      until: '9.0',
-    });
-    if (typeof options === 'number') {
-      return this.faker.string.alpha(options);
-    }
-
-    return this.faker.string.alpha({
-      length: options.count,
-      casing: options.casing,
-      exclude: options.bannedChars,
-    });
-  }
-
-  /**
-   * Generating a string consisting of alpha characters and digits.
-   *
-   * @param count The number of characters and digits to generate. Defaults to `1`.
-   * @param options The options to use.
-   * @param options.casing The casing of the characters. Defaults to `'lower'`.
-   * @param options.bannedChars An array of characters and digits which should be banned in the generated string. Defaults to `[]`.
-   *
-   * @see faker.string.alphanumeric(): For the replacement method.
-   *
-   * @example
-   * faker.random.alphaNumeric() // '2'
-   * faker.random.alphaNumeric(5) // '3e5v7'
-   * faker.random.alphaNumeric(5, { bannedChars: ["a"] }) // 'xszlm'
-   *
-   * @since 3.1.0
-   *
-   * @deprecated Use `faker.string.alphanumeric()` instead.
-   */
-  alphaNumeric(
-    count: number = 1,
-    options: {
-      /**
-       * The casing of the characters.
-       *
-       * @default 'lower'
-       */
-      casing?: Casing;
-      /**
-       * An array of characters and digits which should be banned in the generated string.
-       *
-       * @default []
-       */
-      bannedChars?: ReadonlyArray<LiteralUnion<AlphaNumericChar>> | string;
-    } = {}
-  ): string {
-    deprecated({
-      deprecated: 'faker.random.alphaNumeric()',
-      proposed: 'faker.string.alphanumeric()',
-      since: '8.0',
-      until: '9.0',
-    });
-    return this.faker.string.alphanumeric({
-      length: count,
-      exclude: options.bannedChars,
-      casing: options.casing,
-    });
-  }
-
-  /**
-   * Generates a given length string of digits.
-   *
-   * @param length The number of digits to generate. Defaults to `1`.
-   * @param options The options to use.
-   * @param options.allowLeadingZeros Whether leading zeros are allowed or not. Defaults to `true`.
-   * @param options.bannedDigits An array of digits which should be banned in the generated string. Defaults to `[]`.
-   *
-   * @see faker.string.numeric(): For the replacement method.
-   *
-   * @example
-   * faker.random.numeric() // '2'
-   * faker.random.numeric(5) // '31507'
-   * faker.random.numeric(42) // '00434563150765416546479875435481513188548'
-   * faker.random.numeric(42, { allowLeadingZeros: true }) // '00564846278453876543517840713421451546115'
-   * faker.random.numeric(6, { bannedDigits: ['0'] }) // '943228'
-   *
-   * @since 6.3.0
-   *
-   * @deprecated Use `faker.string.numeric()` instead.
-   */
-  numeric(
-    length: number = 1,
-    options: {
-      /**
-       * Whether leading zeros are allowed or not.
-       *
-       * @default true
-       */
-      allowLeadingZeros?: boolean;
-      /**
-       * An array of digits which should be banned in the generated string.
-       *
-       * @default []
-       */
-      bannedDigits?: ReadonlyArray<LiteralUnion<NumericChar>> | string;
-    } = {}
-  ): string {
-    deprecated({
-      deprecated: 'faker.random.numeric()',
-      proposed: 'faker.string.numeric()',
-      since: '8.0',
-      until: '9.0',
-    });
-    return this.faker.string.numeric({
-      length,
-      allowLeadingZeros: options.allowLeadingZeros,
-      exclude: options.bannedDigits,
-    });
-  }
-}
diff --git a/test/all-functional.spec.ts b/test/all-functional.spec.ts
index 80b1fece..b1819428 100644
--- a/test/all-functional.spec.ts
+++ b/test/all-functional.spec.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import type { Faker, RandomModule, allLocales } from '../src';
+import type { Faker, allLocales } from '../src';
 import { allFakers, fakerEN } from '../src';
 import { keys } from '../src/internal/keys';
 
@@ -55,9 +55,6 @@ const BROKEN_LOCALE_METHODS = {
     zipCode: ['en_HK'],
     zipCodeByState: ['en_HK'],
   },
-  random: {
-    locale: '*', // locale() has been pseudo removed
-  } as SkipConfig<RandomModule>,
   string: {
     fromCharacters: '*',
   },
diff --git a/test/modules/helpers.spec.ts b/test/modules/helpers.spec.ts
index 08dc2b61..6163a0d2 100644
--- a/test/modules/helpers.spec.ts
+++ b/test/modules/helpers.spec.ts
@@ -993,7 +993,7 @@ describe('helpers', () => {
         });
 
         it('replaces a token with a random value for a method with an object parameter', () => {
-          const actual = faker.helpers.fake('{{random.alpha({"count": 3})}}');
+          const actual = faker.helpers.fake('{{string.alpha({"length": 3})}}');
           expect(actual).toMatch(/^[a-z]{3}$/i);
         });
 
diff --git a/test/modules/random.spec.ts b/test/modules/random.spec.ts
deleted file mode 100644
index 94de137e..00000000
--- a/test/modules/random.spec.ts
+++ /dev/null
@@ -1,461 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Faker, FakerError, faker, fakerZH_CN } from '../../src';
-import { seededTests } from '../support/seeded-runs';
-import { times } from './../support/times';
-
-const NON_SEEDED_BASED_RUN = 5;
-
-describe('random', () => {
-  seededTests(faker, 'random', (t) => {
-    t.it('word');
-    t.skip('locale' as 'word'); // locale() has been pseudo removed
-
-    t.describeEach(
-      'alpha',
-      'alphaNumeric',
-      'numeric'
-    )((t) => {
-      t.it('noArgs').it('with length', 5);
-    });
-
-    t.describe('words', (t) => {
-      t.it('noArgs')
-        .it('with length', 5)
-        .it('with length range', { min: 1, max: 5 });
-    });
-  });
-
-  describe.each(times(NON_SEEDED_BASED_RUN).map(() => faker.seed()))(
-    'random seeded tests for seed %i',
-    () => {
-      describe('word', () => {
-        const bannedChars = [
-          '!',
-          '#',
-          '%',
-          '&',
-          '*',
-          ')',
-          '(',
-          '+',
-          '=',
-          '.',
-          '<',
-          '>',
-          '{',
-          '}',
-          '[',
-          ']',
-          ':',
-          ';',
-          "'",
-          '"',
-          '_',
-          '-',
-        ];
-
-        it('should return a random word', () => {
-          const actual = faker.random.word();
-
-          expect(actual).toBeTruthy();
-          expect(actual).toBeTypeOf('string');
-        });
-
-        it.each(times(50))(
-          'should only contain a word without undesirable non-alpha characters (run %i)',
-          () => {
-            const actual = faker.random.word();
-
-            expect(actual).not.satisfy((word: string) =>
-              bannedChars.some((char) => word.includes(char))
-            );
-          }
-        );
-
-        it.each(times(50))(
-          'should only contain a word without undesirable non-alpha characters, locale=zh_CN (run %i)',
-          () => {
-            const actual = fakerZH_CN.random.word();
-
-            expect(actual).not.satisfy((word: string) =>
-              bannedChars.some((char) => word.includes(char))
-            );
-          }
-        );
-
-        it('should throw error if no data are available', () => {
-          const faker = new Faker({
-            locale: [{ metadata: { title: 'custom' } }],
-          });
-
-          expect(() => faker.random.word()).toThrow();
-        });
-      });
-
-      describe('words', () => {
-        it('should return random words', () => {
-          const actual = faker.random.words();
-
-          expect(actual).toBeTruthy();
-          expect(actual).toBeTypeOf('string');
-
-          const words = actual.split(' ');
-          expect(words.length).toBeGreaterThanOrEqual(1);
-          expect(words.length).toBeLessThanOrEqual(3);
-        });
-
-        it('should return 5 random words', () => {
-          const actual = faker.random.words(5);
-
-          expect(actual).toBeTruthy();
-          expect(actual).toBeTypeOf('string');
-
-          const words = actual.split(' ');
-          expect(words).toHaveLength(5);
-        });
-
-        it('should return 3-5 random words', () => {
-          const actual = faker.random.words({ min: 3, max: 5 });
-
-          expect(actual).toBeTruthy();
-          expect(actual).toBeTypeOf('string');
-
-          const words = actual.split(' ');
-          expect(words.length).toBeGreaterThanOrEqual(3);
-          expect(words.length).toBeLessThanOrEqual(5);
-        });
-      });
-
-      describe('alpha', () => {
-        it('should return single letter when no count provided', () => {
-          const actual = faker.random.alpha();
-
-          expect(actual).toHaveLength(1);
-        });
-
-        it('should return mixed letter when no option provided', () => {
-          const actual = faker.random.alpha();
-
-          expect(actual).toMatch(/^[a-z]$/i);
-        });
-
-        it.each([
-          ['upper', /^[A-Z]{250}$/],
-          ['lower', /^[a-z]{250}$/],
-          ['mixed', /^[a-zA-Z]{250}$/],
-        ] as const)('should return %s-case', (casing, pattern) => {
-          const actual = faker.random.alpha({ count: 250, casing });
-          expect(actual).toMatch(pattern);
-        });
-
-        it('should generate many random letters', () => {
-          const actual = faker.random.alpha(5);
-
-          expect(actual).toHaveLength(5);
-        });
-
-        it.each([0, -1, -100])(
-          'should return empty string when length is <= 0',
-          (length) => {
-            const actual = faker.random.alpha(length);
-
-            expect(actual).toBe('');
-          }
-        );
-
-        it('should be able to ban some characters', () => {
-          const actual = faker.random.alpha({
-            count: 5,
-            bannedChars: ['a', 'p', 'A', 'P'],
-          });
-
-          expect(actual).toHaveLength(5);
-          expect(actual).toMatch(/^[b-oq-z]{5}$/i);
-        });
-
-        it('should be able to ban some characters via string', () => {
-          const actual = faker.random.alpha({
-            count: 5,
-            bannedChars: 'apAP',
-          });
-
-          expect(actual).toHaveLength(5);
-          expect(actual).toMatch(/^[b-oq-z]{5}$/i);
-        });
-
-        it('should be able handle mistake in banned characters array', () => {
-          const alphaText = faker.random.alpha({
-            count: 5,
-            bannedChars: ['a', 'a', 'p', 'A', 'A', 'P'],
-          });
-
-          expect(alphaText).toHaveLength(5);
-          expect(alphaText).toMatch(/^[b-oq-z]{5}$/i);
-        });
-
-        it('should throw if all possible characters being banned', () => {
-          const bannedChars = [
-            ...'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
-          ];
-          expect(() =>
-            faker.random.alpha({
-              count: 5,
-              bannedChars,
-            })
-          ).toThrow(
-            new FakerError(
-              'Unable to generate string: No characters to select from.'
-            )
-          );
-        });
-
-        it('should not mutate the input object', () => {
-          const input: {
-            count: number;
-            casing: 'mixed';
-            bannedChars: string[];
-          } = Object.freeze({
-            count: 5,
-            casing: 'mixed',
-            bannedChars: ['a', '%'],
-          });
-
-          expect(() => faker.random.alpha(input)).not.toThrow();
-          expect(input.bannedChars).toEqual(['a', '%']);
-        });
-      });
-
-      describe('alphaNumeric', () => {
-        it('should generate single character when no additional argument was provided', () => {
-          const actual = faker.random.alphaNumeric();
-
-          expect(actual).toHaveLength(1);
-        });
-
-        it.each([
-          ['upper', /^[A-Z0-9]{250}$/],
-          ['lower', /^[a-z0-9]{250}$/],
-          ['mixed', /^[a-zA-Z0-9]{250}$/],
-        ] as const)('should return %s-case', (casing, pattern) => {
-          const actual = faker.random.alphaNumeric(250, { casing });
-          expect(actual).toMatch(pattern);
-        });
-
-        it('should generate many random characters', () => {
-          const actual = faker.random.alphaNumeric(5);
-
-          expect(actual).toHaveLength(5);
-        });
-
-        it.each([0, -1, -100])(
-          'should return empty string when length is <= 0',
-          (length) => {
-            const actual = faker.random.alphaNumeric(length);
-
-            expect(actual).toBe('');
-          }
-        );
-
-        it('should be able to ban all alphabetic characters', () => {
-          const bannedChars = [...'abcdefghijklmnopqrstuvwxyz'];
-          const alphaText = faker.random.alphaNumeric(5, {
-            bannedChars,
-          });
-
-          expect(alphaText).toHaveLength(5);
-          for (const bannedChar of bannedChars) {
-            expect(alphaText).not.includes(bannedChar);
-          }
-        });
-
-        it('should be able to ban all alphabetic characters via string', () => {
-          const bannedChars = 'abcdefghijklmnopqrstuvwxyz';
-          const alphaText = faker.random.alphaNumeric(5, {
-            bannedChars,
-          });
-
-          expect(alphaText).toHaveLength(5);
-          for (const bannedChar of bannedChars) {
-            expect(alphaText).not.includes(bannedChar);
-          }
-        });
-
-        it('should be able to ban all numeric characters', () => {
-          const bannedChars = [...'0123456789'];
-          const alphaText = faker.random.alphaNumeric(5, {
-            bannedChars,
-          });
-
-          expect(alphaText).toHaveLength(5);
-          for (const bannedChar of bannedChars) {
-            expect(alphaText).not.includes(bannedChar);
-          }
-        });
-
-        it('should be able to ban all numeric characters via string', () => {
-          const bannedChars = '0123456789';
-          const alphaText = faker.random.alphaNumeric(5, {
-            bannedChars,
-          });
-
-          expect(alphaText).toHaveLength(5);
-          for (const bannedChar of bannedChars) {
-            expect(alphaText).not.includes(bannedChar);
-          }
-        });
-
-        it('should be able to handle mistake in banned characters array', () => {
-          const alphaText = faker.random.alphaNumeric(5, {
-            bannedChars: ['a', 'p', 'a'],
-            casing: 'lower',
-          });
-
-          expect(alphaText).toHaveLength(5);
-          expect(alphaText).toMatch(/^[0-9b-oq-z]{5}$/);
-        });
-
-        it('should throw if all possible characters being banned', () => {
-          const bannedChars = [...'abcdefghijklmnopqrstuvwxyz0123456789'];
-          expect(() =>
-            faker.random.alphaNumeric(5, {
-              bannedChars,
-              casing: 'lower',
-            })
-          ).toThrow(
-            new FakerError(
-              'Unable to generate string: No characters to select from.'
-            )
-          );
-        });
-
-        it('should throw if all possible characters being banned via string', () => {
-          const bannedChars = 'abcdefghijklmnopqrstuvwxyz0123456789';
-          expect(() =>
-            faker.random.alphaNumeric(5, {
-              bannedChars,
-              casing: 'lower',
-            })
-          ).toThrow();
-        });
-
-        it('should not mutate the input object', () => {
-          const input: {
-            bannedChars: string[];
-          } = Object.freeze({
-            bannedChars: ['a', '0', '%'],
-          });
-
-          expect(() => faker.random.alphaNumeric(5, input)).not.toThrow();
-          expect(input.bannedChars).toEqual(['a', '0', '%']);
-        });
-      });
-
-      describe('numeric', () => {
-        it('should return single digit when no length provided', () => {
-          const actual = faker.random.numeric();
-
-          expect(actual).toHaveLength(1);
-          expect(actual).toMatch(/^[0-9]$/);
-        });
-
-        it.each(times(100))(
-          'should generate random value with a length of %s',
-          (length) => {
-            const actual = faker.random.numeric(length);
-
-            expect(actual).toHaveLength(length);
-            expect(actual).toMatch(/^[0-9]*$/);
-          }
-        );
-
-        it('should return empty string with a length of 0', () => {
-          const actual = faker.random.numeric(0);
-
-          expect(actual).toHaveLength(0);
-        });
-
-        it('should return empty string with a negative length', () => {
-          const actual = faker.random.numeric(-10);
-
-          expect(actual).toHaveLength(0);
-        });
-
-        it('should return a valid numeric string with provided length', () => {
-          const actual = faker.random.numeric(1000);
-
-          expect(actual).toBeTypeOf('string');
-          expect(actual).toHaveLength(1000);
-          expect(actual).toMatch(/^[0-9]+$/);
-        });
-
-        it('should allow leading zeros via option', () => {
-          const actual = faker.random.numeric(15, { allowLeadingZeros: true });
-
-          expect(actual).toMatch(/^[0-9]+$/);
-        });
-
-        it('should allow leading zeros via option and all other digits banned', () => {
-          const actual = faker.random.numeric(4, {
-            allowLeadingZeros: true,
-            bannedDigits: [...'123456789'],
-          });
-
-          expect(actual).toBe('0000');
-        });
-
-        it('should allow leading zeros via option and all other digits banned via string', () => {
-          const actual = faker.random.numeric(4, {
-            allowLeadingZeros: true,
-            bannedDigits: '123456789',
-          });
-
-          expect(actual).toBe('0000');
-        });
-
-        it('should fail on leading zeros via option and all other digits banned', () => {
-          expect(() =>
-            faker.random.numeric(4, {
-              allowLeadingZeros: false,
-              bannedDigits: [...'123456789'],
-            })
-          ).toThrow(
-            new FakerError(
-              'Unable to generate numeric string, because all possible digits are excluded.'
-            )
-          );
-        });
-
-        it('should fail on leading zeros via option and all other digits banned via string', () => {
-          expect(() =>
-            faker.random.numeric(4, {
-              allowLeadingZeros: false,
-              bannedDigits: '123456789',
-            })
-          ).toThrow(
-            new FakerError(
-              'Unable to generate numeric string, because all possible digits are excluded.'
-            )
-          );
-        });
-
-        it('should ban all digits passed via bannedDigits', () => {
-          const actual = faker.random.numeric(1000, {
-            bannedDigits: [...'c84U1'],
-          });
-
-          expect(actual).toHaveLength(1000);
-          expect(actual).toMatch(/^[0235679]{1000}$/);
-        });
-
-        it('should ban all digits passed via bannedDigits via string', () => {
-          const actual = faker.random.numeric(1000, {
-            bannedDigits: 'c84U1',
-          });
-
-          expect(actual).toHaveLength(1000);
-          expect(actual).toMatch(/^[0235679]{1000}$/);
-        });
-      });
-    }
-  );
-});