Domain-Specific Data

/**
 * 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;

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 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;

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 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;

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 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;

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 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;

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 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;

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;
}

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 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 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 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 })
}));