Specialized modules for various domains including vehicles, animals, books, food, music, science, and other topic-specific data generation. These modules provide realistic data for specific industries and use cases.
Generate automotive and transportation-related data including manufacturers, models, and identification numbers.
/**
* Generate a random vehicle name (manufacturer + model)
* @returns Complete vehicle name
*/
vehicle(): string;
/**
* Generate a vehicle manufacturer name
* @returns Car manufacturer (e.g., 'Ford', 'Toyota')
*/
manufacturer(): string;
/**
* Generate a vehicle model name
* @returns Car model (e.g., 'Explorer', 'Camry')
*/
model(): string;
/**
* Generate a vehicle type
* @returns Vehicle type (e.g., 'Coupe', 'SUV')
*/
type(): string;
/**
* Generate a fuel type
* @returns Fuel type (e.g., 'Electric', 'Gasoline')
*/
fuel(): string;
/**
* Generate a Vehicle Identification Number (VIN)
* @returns Valid 17-character VIN
*/
vin(): string;
/**
* Generate a Vehicle Registration Mark (VRM/License Plate)
* @returns License plate number
*/
vrm(): string;
/**
* Generate a bicycle type
* @returns Bicycle type (e.g., 'Mountain Bike')
*/
bicycle(): string;Usage Examples:
import { faker } from "@faker-js/faker";
// Generate complete vehicle information
const vehicleName = faker.vehicle.vehicle();
// Example: 'BMW Explorer'
const manufacturer = faker.vehicle.manufacturer();
// Example: 'Ford'
const model = faker.vehicle.model();
// Example: 'Explorer'
const vehicleType = faker.vehicle.type();
// Example: 'Coupe'
const fuel = faker.vehicle.fuel();
// Example: 'Electric'
// Generate vehicle identifiers
const vin = faker.vehicle.vin();
// Example: 'YV1MH682762184654'
const licensePlate = faker.vehicle.vrm();
// Example: 'GA1234'
// Alternative transportation
const bikeType = faker.vehicle.bicycle();
// Example: 'Road Bike'
// Create vehicle listing
const vehicleListing = {
name: faker.vehicle.vehicle(),
type: faker.vehicle.type(),
fuel: faker.vehicle.fuel(),
vin: faker.vehicle.vin(),
color: faker.color.human(),
price: faker.commerce.price({ min: 15000, max: 60000, symbol: '$' })
};Generate animal names and species across different categories.
/**
* Generate a general animal type
* @returns Animal type (e.g., 'dog', 'cat')
*/
type(): string;
/**
* Generate a dog breed
* @returns Dog breed (e.g., 'Irish Water Spaniel')
*/
dog(): string;
/**
* Generate a cat breed
* @returns Cat breed (e.g., 'Singapura')
*/
cat(): string;
/**
* Generate a snake species
* @returns Snake species (e.g., 'Eyelash viper')
*/
snake(): string;
/**
* Generate a bear species
* @returns Bear species (e.g., 'Grizzly bear')
*/
bear(): string;
/**
* Generate a bird species
* @returns Bird species (e.g., 'Cardinal')
*/
bird(): string;
/**
* Generate a cetacean species (whales, dolphins)
* @returns Cetacean species (e.g., 'Blue whale')
*/
cetacean(): string;
/**
* Generate a cow breed
* @returns Cow breed (e.g., 'Holstein')
*/
cow(): string;
/**
* Generate a crocodilian species
* @returns Crocodilian species (e.g., 'Alligator')
*/
crocodilian(): string;
/**
* Generate a fish species
* @returns Fish species (e.g., 'Salmon')
*/
fish(): string;
/**
* Generate a horse breed
* @returns Horse breed (e.g., 'Arabian')
*/
horse(): string;
/**
* Generate an insect species
* @returns Insect species (e.g., 'Butterfly')
*/
insect(): string;
/**
* Generate a lion subspecies
* @returns Lion subspecies (e.g., 'Asiatic lion')
*/
lion(): string;
/**
* Generate a rabbit breed
* @returns Rabbit breed (e.g., 'Angora')
*/
rabbit(): string;
/**
* Generate a rodent species
* @returns Rodent species (e.g., 'Hamster')
*/
rodent(): string;Usage Examples:
import { faker } from "@faker-js/faker";
// Generate various animal types
const animalType = faker.animal.type();
// Example: 'dog'
const dogBreed = faker.animal.dog();
// Example: 'Irish Water Spaniel'
const catBreed = faker.animal.cat();
// Example: 'Singapura'
const snakeSpecies = faker.animal.snake();
// Example: 'Eyelash viper'
// Create animal profiles
const petProfile = {
type: faker.animal.type(),
breed: faker.animal.dog(),
name: faker.person.firstName(),
age: faker.number.int({ min: 1, max: 15 }),
color: faker.color.human()
};
const wildlifeProfile = {
species: faker.animal.bear(),
habitat: faker.location.country(),
weight: faker.number.int({ min: 50, max: 800 })
};Generate book-related data including titles, authors, genres, and publishing information.
/**
* Generate a random author name
* @returns Author name (e.g., 'William Shakespeare')
*/
author(): string;
/**
* Generate a book format
* @returns Book format (e.g., 'Hardcover', 'Paperback')
*/
format(): string;
/**
* Generate a book genre
* @returns Book genre (e.g., 'Fantasy', 'Mystery')
*/
genre(): string;
/**
* Generate a publisher name
* @returns Publisher name (e.g., 'Penguin Random House')
*/
publisher(): string;
/**
* Generate a book series name
* @returns Series name (e.g., 'Harry Potter')
*/
series(): string;
/**
* Generate a book title
* @returns Book title (e.g., 'The Great Gatsby')
*/
title(): string;Usage Examples:
import { faker } from "@faker-js/faker";
// Generate book information
const bookTitle = faker.book.title();
// Example: 'The Great Gatsby'
const author = faker.book.author();
// Example: 'William Shakespeare'
const genre = faker.book.genre();
// Example: 'Fantasy'
const publisher = faker.book.publisher();
// Example: 'Penguin Random House'
const format = faker.book.format();
// Example: 'Hardcover'
const series = faker.book.series();
// Example: 'Harry Potter'
// Create complete book record
const bookRecord = {
title: faker.book.title(),
author: faker.book.author(),
isbn: faker.commerce.isbn(),
genre: faker.book.genre(),
publisher: faker.book.publisher(),
format: faker.book.format(),
price: faker.commerce.price({ min: 5, max: 30, symbol: '$' }),
publishedYear: faker.date.between({
from: '1900-01-01',
to: new Date()
}).getFullYear()
};Generate food-related data including dishes, ingredients, and culinary descriptions.
/**
* Generate a food adjective
* @returns Food adjective (e.g., 'crispy', 'tender')
*/
adjective(): string;
/**
* Generate a dish description
* @returns Detailed dish description
*/
description(): string;
/**
* Generate a dish name
* @returns Dish name (e.g., 'Beef Wellington')
*/
dish(): string;
/**
* Generate an ethnic cuisine type
* @returns Cuisine type (e.g., 'Italian', 'Thai')
*/
ethnicCategory(): string;
/**
* Generate a fruit name
* @returns Fruit name (e.g., 'Apple', 'Mango')
*/
fruit(): string;
/**
* Generate a general ingredient
* @returns Ingredient name (e.g., 'Salt', 'Flour')
*/
ingredient(): string;
/**
* Generate a meat type
* @returns Meat type (e.g., 'Beef', 'Chicken')
*/
meat(): string;
/**
* Generate a spice name
* @returns Spice name (e.g., 'Cinnamon', 'Paprika')
*/
spice(): string;
/**
* Generate a vegetable name
* @returns Vegetable name (e.g., 'Carrot', 'Broccoli')
*/
vegetable(): string;Usage Examples:
import { faker } from "@faker-js/faker";
// Generate food items
const dish = faker.food.dish();
// Example: 'Beef Wellington'
const description = faker.food.description();
// Example: 'An exquisite ostrich roast, infused with the essence of longan'
const adjective = faker.food.adjective();
// Example: 'crispy'
const ingredient = faker.food.ingredient();
// Example: 'Salt'
const meat = faker.food.meat();
// Example: 'Beef'
const vegetable = faker.food.vegetable();
// Example: 'Carrot'
const fruit = faker.food.fruit();
// Example: 'Apple'
const spice = faker.food.spice();
// Example: 'Cinnamon'
// Create recipe components
const recipe = {
name: faker.food.dish(),
description: faker.food.description(),
cuisine: faker.food.ethnicCategory(),
mainIngredient: faker.food.meat(),
vegetables: Array.from({ length: 3 }, () => faker.food.vegetable()),
spices: Array.from({ length: 2 }, () => faker.food.spice()),
cookingTime: faker.number.int({ min: 15, max: 180 })
};Generate music-related data including artists, albums, genres, and songs.
/**
* Generate an album name
* @returns Album name (e.g., '1989', 'Abbey Road')
*/
album(): string;
/**
* Generate an artist name
* @returns Artist name (e.g., 'The Beatles')
*/
artist(): string;
/**
* Generate a music genre
* @returns Music genre (e.g., 'Reggae', 'Jazz')
*/
genre(): string;
/**
* Generate a song name
* @returns Song name (e.g., 'Bohemian Rhapsody')
*/
songName(): string;Usage Examples:
import { faker } from "@faker-js/faker";
// Generate music information
const artist = faker.music.artist();
// Example: 'The Beatles'
const album = faker.music.album();
// Example: '1989'
const genre = faker.music.genre();
// Example: 'Reggae'
const song = faker.music.songName();
// Example: 'Bohemian Rhapsody'
// Create music catalog entry
const musicTrack = {
title: faker.music.songName(),
artist: faker.music.artist(),
album: faker.music.album(),
genre: faker.music.genre(),
duration: `${faker.number.int({ min: 2, max: 8 })}:${faker.number.int({ min: 10, max: 59 })}`,
releaseYear: faker.date.between({
from: '1950-01-01',
to: new Date()
}).getFullYear()
};Generate scientific data including chemical elements, units, and scientific terminology.
/**
* Generate a random chemical element
* @returns Chemical element object with symbol, name, and atomic number
*/
chemicalElement(): ChemicalElement;
/**
* Generate a scientific unit
* @returns Unit object with name and symbol
*/
unit(): Unit;Type Definitions:
interface ChemicalElement {
/** The symbol for the element (e.g., 'He') */
symbol: string;
/** The name for the element (e.g., 'Helium') */
name: string;
/** The atomic number for the element (e.g., 2) */
atomicNumber: number;
}
interface Unit {
/** The long version of the unit (e.g., 'meter') */
name: string;
/** The short version/abbreviation (e.g., 'm') */
symbol: string;
}Usage Examples:
import { faker } from "@faker-js/faker";
// Generate chemical elements
const element = faker.science.chemicalElement();
// Example: { symbol: 'H', name: 'Hydrogen', atomicNumber: 1 }
const elementSymbol = faker.science.chemicalElement().symbol;
// Example: 'He'
const elementName = faker.science.chemicalElement().name;
// Example: 'Helium'
// Generate scientific units
const unit = faker.science.unit();
// Example: { name: 'meter', symbol: 'm' }
const unitName = faker.science.unit().name;
// Example: 'second'
const unitSymbol = faker.science.unit().symbol;
// Example: 's'
// Create scientific data
const experiment = {
element: faker.science.chemicalElement(),
measurement: faker.number.float({ min: 0.1, max: 100, fractionDigits: 3 }),
unit: faker.science.unit(),
temperature: `${faker.number.int({ min: -273, max: 1000 })}°C`,
researcher: faker.person.fullName()
};Generate aviation-related data including airlines, aircraft types, and airport codes.
/**
* Generate an airline name
* @returns Airline name (e.g., 'American Airlines')
*/
airline(): string;
/**
* Generate an airplane name/model
* @returns Aircraft model (e.g., 'Boeing 737')
*/
airplane(): string;
/**
* Generate an airport name
* @returns Airport name (e.g., 'John F. Kennedy International')
*/
airport(): string;
/**
* Generate a flight number
* @param options - Flight number options
* @returns Flight number (e.g., 'AA1234')
*/
flightNumber(options?: {
/** Include airline code prefix */
addAirlineCode?: boolean;
/** Length of numeric part */
length?: { min: number; max: number };
}): string;
/**
* Generate a flight recording status
* @returns Recording status
*/
recordLocator(): string;
/**
* Generate a seat assignment
* @param options - Seat options
* @returns Seat number (e.g., '12A')
*/
seat(options?: {
/** Aircraft type for seat configuration */
aircraftType?: AircraftType;
}): string;Generate system-related data including file extensions, MIME types, and directory paths.
/**
* Generate a common file extension
* @returns File extension (e.g., 'pdf', 'jpg')
*/
commonFileExt(): string;
/**
* Generate a common file name
* @param ext - Optional file extension
* @returns File name with extension
*/
commonFileName(ext?: string): string;
/**
* Generate a common file type
* @returns File type category (e.g., 'audio', 'image')
*/
commonFileType(): string;
/**
* Generate a directory path
* @returns Unix-style directory path
*/
directoryPath(): string;
/**
* Generate a file extension
* @returns File extension
*/
fileExt(mimeType?: string): string;
/**
* Generate a file name
* @param options - File name options
* @returns File name with extension
*/
fileName(options?: {
/** Include extension in filename */
extensionCount?: number;
}): string;
/**
* Generate a file path
* @returns Complete file path
*/
filePath(): string;
/**
* Generate a file type
* @returns MIME type (e.g., 'image/jpeg')
*/
fileType(): string;
/**
* Generate a MIME type
* @returns MIME type string
*/
mimeType(): string;
/**
* Generate a semantic version string
* @returns Semantic version (e.g., '1.2.3')
*/
semver(): string;Generate development-related data including Git commit information and technical terms.
/**
* Generate a Git branch name
* @returns Branch name (e.g., 'feature/user-auth')
*/
branch(): string;
/**
* Generate a Git commit entry
* @param options - Commit options
* @returns Commit object with hash, date, message, etc.
*/
commitEntry(options?: {
/** Merge commit flag */
merge?: boolean;
/** Reference date for commit timestamp */
refDate?: string | Date | number;
}): GitCommitEntry;
/**
* Generate a Git commit message
* @returns Commit message
*/
commitMessage(): string;
/**
* Generate a Git commit SHA hash
* @param options - SHA options
* @returns SHA hash string
*/
commitSha(options?: {
/** Length of SHA (short vs full) */
length?: number;
}): string;
/**
* Generate a short Git commit SHA
* @returns Short SHA hash
*/
shortSha(): string;import { faker } from "@faker-js/faker";
const petStoreInventory = Array.from({ length: 50 }, () => ({
id: faker.string.uuid(),
type: faker.animal.type(),
breed: faker.datatype.boolean() ? faker.animal.dog() : faker.animal.cat(),
name: faker.person.firstName(),
age: faker.number.int({ min: 1, max: 10 }),
price: faker.commerce.price({ min: 50, max: 2000, symbol: '$' }),
description: `A friendly ${faker.food.adjective()} ${faker.animal.type()}`,
available: faker.datatype.boolean({ probability: 0.8 })
}));import { faker } from "@faker-js/faker";
const menuItems = Array.from({ length: 20 }, () => ({
id: faker.string.uuid(),
name: faker.food.dish(),
description: faker.food.description(),
category: faker.food.ethnicCategory(),
ingredients: Array.from({ length: faker.number.int({ min: 3, max: 8 }) }, () =>
faker.food.ingredient()
),
spices: Array.from({ length: faker.number.int({ min: 1, max: 4 }) }, () =>
faker.food.spice()
),
price: faker.commerce.price({ min: 8, max: 45, symbol: '$' }),
isVegetarian: faker.datatype.boolean({ probability: 0.3 }),
preparationTime: faker.number.int({ min: 10, max: 45 })
}));import { faker } from "@faker-js/faker";
const musicLibrary = Array.from({ length: 100 }, () => ({
id: faker.string.uuid(),
title: faker.music.songName(),
artist: faker.music.artist(),
album: faker.music.album(),
genre: faker.music.genre(),
duration: faker.number.int({ min: 120, max: 480 }), // seconds
releaseDate: faker.date.between({ from: '1950-01-01', to: new Date() }),
trackNumber: faker.number.int({ min: 1, max: 20 }),
rating: faker.number.float({ min: 1, max: 5, fractionDigits: 1 })
}));Most domain modules respect the current locale:
Domain modules provide realistic combinations: