diff --git a/readme.md b/readme.md
index b473c7c..b8a3e94 100644
--- a/readme.md
+++ b/readme.md
@@ -22,16 +22,16 @@ Generate PHP class instances populated with fake dummy data using <a href="https
 - [Upgrading](#upgrading)
 - [Introduction](#introduction)
 - [Setup](#setup)
-    - [HasFactory Trait](#hasfactory-trait)
-    - [Class Factory](#class-factory)
+  - [HasDummyFactory Trait](#hasdummyfactory-trait)
+  - [Class Factory](#class-factory)
 - [Usage](#usage)
-    - [Factory States](#factory-states)
-    - [Eloquent Attributes](#eloquent-attributes)
-    - [Factory Callbacks](#factory-callbacks)
-    - [Factory Sequences](#factory-sequences)
-    - [Factory Collections](#factory-collections)
-    - [Factory Macros](#factory-macros)
-    - [IDE Type Inference](#ide-type-inference)
+  - [Factory States](#factory-states)
+  - [Eloquent Attributes](#eloquent-attributes)
+  - [Factory Callbacks](#factory-callbacks)
+  - [Factory Sequences](#factory-sequences)
+  - [Factory Collections](#factory-collections)
+  - [Factory Macros](#factory-macros)
+  - [IDE Type Inference](#ide-type-inference)
 
 ## Requirements
 
@@ -49,38 +49,62 @@ composer require directorytree/dummy --dev
 
 ### From v1 to v2
 
-Dummy v2 changes the `HasFactory` instance transformer to receive a `DirectoryTree\Dummy\Data` object instead of a raw array. This gives you array access plus helper methods for reading generated attributes.
+Dummy v2 renames the trait API so it is explicitly Dummy-owned and does not reserve the common `factory()` method name on your classes.
+
+1. Replace `DirectoryTree\Dummy\HasFactory` with `DirectoryTree\Dummy\HasDummyFactory`.
+2. Replace `use HasFactory;` with `use HasDummyFactory;`.
+3. Replace `YourClass::factory()` calls with `YourClass::dummy()`.
+4. Rename `toFactoryInstance` to `toDummyInstance`.
+5. Rename `getFactoryDefinition` to `getDummyDefinition`.
+6. Change the `toDummyInstance` argument from `array` to `DirectoryTree\Dummy\DummyData`.
 
 Before:
 
 ```php
-protected static function toFactoryInstance(array $attributes): static
+use DirectoryTree\Dummy\HasFactory;
+
+class Reservation
 {
-    return new static(
-        $attributes['name'],
-        $attributes['email'],
-    );
+    use HasFactory;
+
+    protected static function toFactoryInstance(array $attributes): static
+    {
+        return new static(
+            $attributes['name'],
+            $attributes['email'],
+        );
+    }
 }
+
+$reservation = Reservation::factory()->make();
 ```
 
 After:
 
 ```php
-use DirectoryTree\Dummy\Data;
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\HasDummyFactory;
 
-protected static function toFactoryInstance(Data $attributes): static
+class Reservation
 {
-    return new static(
-        $attributes['name'],
-        $attributes['email'],
-    );
+    use HasDummyFactory;
+
+    protected static function toDummyInstance(DummyData $attributes): static
+    {
+        return new static(
+            $attributes['name'],
+            $attributes['email'],
+        );
+    }
 }
+
+$reservation = Reservation::dummy()->make();
 ```
 
 If your constructor or factory method needs a plain array, call `all()`:
 
 ```php
-protected static function toFactoryInstance(Data $attributes): static
+protected static function toDummyInstance(DummyData $attributes): static
 {
     return new static($attributes->all());
 }
@@ -126,36 +150,36 @@ Dummy provides you with a simple way to generate dummy instances of your classes
 
 ```php
 // Generate one instance:
-$reservation = Reservation::factory()->make();
+$reservation = Reservation::dummy()->make();
 
 // Generate multiple instances:
-$collection = Reservation::factory()->count(5)->make();
+$collection = Reservation::dummy()->count(5)->make();
 ```
 
 ## Setup
 
 Dummy provides you two different ways to generate classes with dummy data.
 
-### HasFactory Trait
+### HasDummyFactory Trait
 
-The `HasFactory` trait is applied directly to the class you would like to generate dummy instances of.
+The `HasDummyFactory` trait is applied directly to the class you would like to generate dummy instances of.
 
-To use the `HasFactory` trait, you must implement the `toFactoryInstance` and `getFactoryDefinition` methods:
+To use the `HasDummyFactory` trait, you must implement the `toDummyInstance` and `getDummyDefinition` methods:
 
 ```php
 namespace App\Data;
 
 use DateTime;
 use Faker\Generator;
-use DirectoryTree\Dummy\Data;
-use DirectoryTree\Dummy\HasFactory;
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\HasDummyFactory;
 
 /**
- * @use HasFactory<Reservation>
+ * @use HasDummyFactory<Reservation>
  */
 class Reservation
 {
-    use HasFactory;
+    use HasDummyFactory;
     
     /**
      * Constructor.
@@ -169,7 +193,7 @@ class Reservation
     /**
      * Define the factory's default state.
      */
-    protected static function getFactoryDefinition(Generator $faker): array
+    protected static function getDummyDefinition(Generator $faker): array
     {
         return [
             'name' => $faker->name(),
@@ -181,7 +205,7 @@ class Reservation
     /**
      * Create a new instance of the class using the factory definition.
      */
-    protected static function toFactoryInstance(Data $attributes): static
+    protected static function toDummyInstance(DummyData $attributes): static
     {
         return new static(
             $attributes['name'],
@@ -192,32 +216,32 @@ class Reservation
 }
 ```
 
-The `$attributes` argument passed into `toFactoryInstance` is a `DirectoryTree\Dummy\Data` instance. It supports array access and common data helpers, such as `get`, `has`, `filled`, `notFilled`, `boolean`, `integer`, `enum`, `enums`, `only`, `except`, `collect`, and `all`.
+The `$attributes` argument passed into `toDummyInstance` is a `DirectoryTree\Dummy\DummyData` instance. It supports array access and common data helpers, such as `get`, `has`, `filled`, `notFilled`, `boolean`, `integer`, `enum`, `enums`, `only`, `except`, `collect`, and `all`.
 
-Once implemented, you may call the `Reservation::factory()` method to create a new dummy factory:
+Once implemented, you may call the `Reservation::dummy()` method to create a new dummy factory:
 
 ```php
-$factory = Reservation::factory();
+$factory = Reservation::dummy();
 ```
 
 #### Dynamic State Methods
 
-The `HasFactory` trait supports defining dynamic state methods. You can define state methods in your class using the format `get{StateName}State` and call them dynamically on the factory:
+The `HasDummyFactory` trait supports defining dynamic state methods. You can define state methods in your class using the format `get{StateName}State` and call them dynamically on the factory:
 
 ```php
 namespace App\Data;
 
 use DateTime;
 use Faker\Generator;
-use DirectoryTree\Dummy\Data;
-use DirectoryTree\Dummy\HasFactory;
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\HasDummyFactory;
 
 /**
- * @use HasFactory<Reservation>
+ * @use HasDummyFactory<Reservation>
  */
 class Reservation
 {
-    use HasFactory;
+    use HasDummyFactory;
 
     public function __construct(
         public string $name,
@@ -226,8 +250,8 @@ class Reservation
         public string $status = 'pending',
         public string $type = 'standard',
     ) {}
-    
-     // Dynamic state methods...
+
+    // Dynamic state methods...
 
     public static function getConfirmedState(): array
     {
@@ -247,7 +271,7 @@ class Reservation
         return ['status' => 'cancelled'];
     }
 
-    protected static function toFactoryInstance(Data $attributes): self
+    protected static function toDummyInstance(DummyData $attributes): self
     {
         return new static(
             $attributes['name'],
@@ -258,7 +282,7 @@ class Reservation
         );
     }
 
-    protected static function getFactoryDefinition(Generator $faker): array
+    protected static function getDummyDefinition(Generator $faker): array
     {
         return [
             'name' => $faker->name(),
@@ -273,13 +297,13 @@ You can then use these state methods dynamically:
 
 ```php
 // Create a confirmed reservation
-$confirmed = Reservation::factory()->confirmed()->make();
+$confirmed = Reservation::dummy()->confirmed()->make();
 
 // Create a premium reservation
-$premium = Reservation::factory()->premium()->make();
+$premium = Reservation::dummy()->premium()->make();
 
 // Chain multiple states
-$premiumCancelled = Reservation::factory()->premium()->cancelled()->make();
+$premiumCancelled = Reservation::dummy()->premium()->cancelled()->make();
 ```
 
 ### Class Factory
@@ -333,7 +357,7 @@ Once you've defined a factory, you can generate dummy instances of your class us
 
 ```php
 // Using the trait:
-$reservation = Reservation::factory()->make();
+$reservation = Reservation::dummy()->make();
 
 // Using the factory class:
 $reservation = ReservationFactory::new()->make();
@@ -342,7 +366,7 @@ $reservation = ReservationFactory::new()->make();
 To add or override attributes in your definition, you may pass an array of attributes to the `make` method:
 
 ```php
-$reservation = Reservation::factory()->make([
+$reservation = Reservation::dummy()->make([
     'name' => 'John Doe',
 ]);
 ```
@@ -352,19 +376,19 @@ To generate multiple instances of the class, you may use the `count` method:
 > This will return an `Illuminate\Support\Collection` instance containing the generated classes.
 
 ```php
-$collection = Reservation::factory()->count(5)->make();
+$collection = Reservation::dummy()->count(5)->make();
 ```
 
 If you have a counted factory but need one instance, use `makeOne`:
 
 ```php
-$reservation = Reservation::factory()->count(5)->makeOne();
+$reservation = Reservation::dummy()->count(5)->makeOne();
 ```
 
 To make several instances with a different state record for each one, use `makeMany`:
 
 ```php
-$collection = Reservation::factory()->makeMany([
+$collection = Reservation::dummy()->makeMany([
     ['name' => 'Taylor Otwell'],
     ['name' => 'Nuno Maduro'],
 ]);
@@ -373,7 +397,7 @@ $collection = Reservation::factory()->makeMany([
 You may also defer generation by creating a lazy callback:
 
 ```php
-$makeReservation = Reservation::factory()->lazy([
+$makeReservation = Reservation::dummy()->lazy([
     'name' => 'John Doe',
 ]);
 
@@ -382,7 +406,7 @@ $reservation = $makeReservation();
 
 ### Factory States
 
-State manipulation methods allow you to define discrete modifications 
+State manipulation methods allow you to define discrete modifications
 that can be applied to your dummy factories in any combination.
 
 For example, your `App\Factories\Reservation` factory might contain a `tomorrow`
@@ -408,7 +432,7 @@ class ReservationFactory extends Factory
 You may prepend a state when you need it evaluated before the factory's existing states:
 
 ```php
-$reservation = Reservation::factory()
+$reservation = Reservation::dummy()
     ->tomorrow()
     ->prependState([
         'name' => 'Early State',
@@ -424,7 +448,7 @@ When Laravel's Eloquent is installed, Dummy will expand Eloquent model instances
 use App\Models\Company;
 use App\Models\User;
 
-$reservation = Reservation::factory()->make([
+$reservation = Reservation::dummy()->make([
     'company_id' => Company::factory(),
     'user_id' => User::factory()->create(),
 ]);
@@ -433,7 +457,7 @@ $reservation = Reservation::factory()->make([
 This also works for values returned from attribute closures, so dependent attributes can use previously expanded keys:
 
 ```php
-$reservation = Reservation::factory()->make([
+$reservation = Reservation::dummy()->make([
     'company_id' => Company::factory(),
     'user_id' => fn (array $attributes) => User::factory([
         'company_id' => $attributes['company_id'],
@@ -443,9 +467,9 @@ $reservation = Reservation::factory()->make([
 
 ### Factory Callbacks
 
-Factory callbacks are registered using the `afterMaking` method and allow you to perform 
+Factory callbacks are registered using the `afterMaking` method and allow you to perform
 additional tasks after making or creating a class. You should register these callbacks
-by defining a `configure` method on your factory class. This method will be 
+by defining a `configure` method on your factory class. This method will be
 automatically called when the factory is instantiated:
 
 ```php
@@ -475,15 +499,15 @@ $reservation = ReservationFactory::new()
 
 ### Factory Sequences
 
-Sometimes you may wish to alternate the value of a given attribute for each generated 
-class. 
+Sometimes you may wish to alternate the value of a given attribute for each generated
+class.
 
 You may accomplish this by defining a state transformation as a `sequence`:
 
 ```php
-Reservation::factory()
+Reservation::dummy()
     ->count(3)
-     ->sequence(
+    ->sequence(
         ['datetime' => new Datetime('tomorrow')],
         ['datetime' => new Datetime('next week')],
         ['datetime' => new Datetime('next month')],
@@ -525,22 +549,22 @@ Factory::macro('named', function (string $name) {
     ]);
 });
 
-$reservation = Reservation::factory()->named('John Doe')->make();
+$reservation = Reservation::dummy()->named('John Doe')->make();
 ```
 
 ### IDE Type Inference
 
 Dummy includes generic PHPDoc annotations so static analysis tools and IDEs can infer factory return types.
 
-When using the `HasFactory` trait, add an `@use` annotation to your class:
+When using the `HasDummyFactory` trait, add an `@use` annotation to your class:
 
 ```php
 /**
- * @use HasFactory<Reservation>
+ * @use HasDummyFactory<Reservation>
  */
 class Reservation
 {
-    use HasFactory;
+    use HasDummyFactory;
 
     // ...
 }
@@ -558,4 +582,4 @@ class ReservationFactory extends Factory
 }
 ```
 
-These annotations allow tools to infer that `Reservation::factory()->makeOne()` and `ReservationFactory::new()->makeOne()` return a `Reservation` instance.
+These annotations allow tools to infer that `Reservation::dummy()->makeOne()` and `ReservationFactory::new()->makeOne()` return a `Reservation` instance.
diff --git a/src/Data.php b/src/DummyData.php
similarity index 99%
rename from src/Data.php
rename to src/DummyData.php
index efa67ca..5c83831 100644
--- a/src/Data.php
+++ b/src/DummyData.php
@@ -19,7 +19,7 @@
  * @implements ArrayAccess<TKey, TValue>
  * @implements IteratorAggregate<TKey, TValue>
  */
-class Data implements ArrayAccess, IteratorAggregate, JsonSerializable
+class DummyData implements ArrayAccess, IteratorAggregate, JsonSerializable
 {
     /**
      * The data attributes.
diff --git a/src/Factory.php b/src/Factory.php
index 49d089c..f07f3a8 100644
--- a/src/Factory.php
+++ b/src/Factory.php
@@ -80,7 +80,7 @@ protected function definition(): array
      */
     protected function generate(array $attributes): mixed
     {
-        return new Data($attributes);
+        return new DummyData($attributes);
     }
 
     /**
diff --git a/src/HasFactory.php b/src/HasDummyFactory.php
similarity index 58%
rename from src/HasFactory.php
rename to src/HasDummyFactory.php
index 888599b..d761009 100644
--- a/src/HasFactory.php
+++ b/src/HasDummyFactory.php
@@ -7,7 +7,7 @@
 /**
  * @template TFactoryInstance of object
  */
-trait HasFactory
+trait HasDummyFactory
 {
     /**
      * Create a new dummy factory.
@@ -15,40 +15,40 @@ trait HasFactory
      * @param  array<string, mixed>  $attributes
      * @return Factory<TFactoryInstance>
      */
-    public static function factory(array $attributes = []): Factory
+    public static function dummy(array $attributes = []): Factory
     {
-        return static::newFactory($attributes)->using(
-            fn (Generator $faker, array $attributes) => static::toFactoryInstance(new Data($attributes))
+        return static::newDummyFactory($attributes)->using(
+            fn (Generator $faker, array $attributes) => static::toDummyInstance(new DummyData($attributes))
         );
     }
 
     /**
-     * Get a new factory instance.
+     * Get a new dummy factory instance.
      *
      * @param  array<string, mixed>  $attributes
      * @return Factory<TFactoryInstance>
      */
-    protected static function newFactory(array $attributes): Factory
+    protected static function newDummyFactory(array $attributes): Factory
     {
         $class = static::class;
 
         return (new Factory(class: static::class))->state(function () use ($class) {
-            return $class::getFactoryDefinition($this->faker());
+            return $class::getDummyDefinition($this->faker());
         })->state($attributes);
     }
 
     /**
      * Transform the dummy data into a class instance.
      *
-     * @param  Data<string, mixed>  $attributes
+     * @param  DummyData<string, mixed>  $attributes
      * @return TFactoryInstance
      */
-    abstract protected static function toFactoryInstance(Data $attributes): mixed;
+    abstract protected static function toDummyInstance(DummyData $attributes): mixed;
 
     /**
      * Define the dummy data definition.
      *
      * @return array<string, mixed>
      */
-    abstract protected static function getFactoryDefinition(Generator $faker): array;
+    abstract protected static function getDummyDefinition(Generator $faker): array;
 }
diff --git a/tests/EloquentAttributesTest.php b/tests/EloquentAttributesTest.php
index e871450..6335ab2 100644
--- a/tests/EloquentAttributesTest.php
+++ b/tests/EloquentAttributesTest.php
@@ -3,7 +3,7 @@
 use DirectoryTree\Dummy\Tests\Fixtures\EloquentFactoryStub;
 use DirectoryTree\Dummy\Tests\Fixtures\EloquentModelStub;
 use DirectoryTree\Dummy\Tests\Fixtures\FactoryStub;
-use DirectoryTree\Dummy\Tests\Fixtures\HasFactoryWithEloquentAttributesStub;
+use DirectoryTree\Dummy\Tests\Fixtures\HasDummyFactoryWithEloquentAttributesStub;
 
 it('expands eloquent factories and models in factory attributes', function () {
     $instance = FactoryStub::new()->make([
@@ -28,7 +28,7 @@
 });
 
 it('expands eloquent factories and models in has factory definitions', function () {
-    $instance = HasFactoryWithEloquentAttributesStub::factory()->make();
+    $instance = HasDummyFactoryWithEloquentAttributesStub::dummy()->make();
 
     expect($instance->model_id)->toBe(123);
     expect($instance->factory_id)->toBe(456);
@@ -36,7 +36,7 @@
 });
 
 it('expands eloquent attributes after state overrides are applied', function () {
-    $instance = HasFactoryWithEloquentAttributesStub::factory([
+    $instance = HasDummyFactoryWithEloquentAttributesStub::dummy([
         'factory_id' => new EloquentFactoryStub(789),
     ])->make();
 
@@ -45,7 +45,7 @@
 });
 
 it('expands has factory attributes with factory definition context', function () {
-    $instance = HasFactoryWithEloquentAttributesStub::factory([
+    $instance = HasDummyFactoryWithEloquentAttributesStub::dummy([
         'dependent_id' => fn (array $attributes) => new EloquentModelStub($attributes['factory_id'] + 2),
     ])->make();
 
diff --git a/tests/FactoryTest.php b/tests/FactoryTest.php
index b384ecb..b91dd3b 100644
--- a/tests/FactoryTest.php
+++ b/tests/FactoryTest.php
@@ -1,6 +1,6 @@
 <?php
 
-use DirectoryTree\Dummy\Data;
+use DirectoryTree\Dummy\DummyData;
 use DirectoryTree\Dummy\Tests\Fixtures\DataStatus;
 use DirectoryTree\Dummy\Tests\Fixtures\FactoryClassStub;
 use DirectoryTree\Dummy\Tests\Fixtures\FactoryStub;
@@ -12,14 +12,14 @@
 it('can generate single instance', function () {
     $instance = FactoryStub::new()->make();
 
-    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance)->toBeInstanceOf(DummyData::class);
 });
 
 it('can generate multiple instances in a collection', function () {
     $collection = FactoryStub::new()->count(5)->make();
 
     $collection->each(
-        fn ($instance) => expect($instance)->toBeInstanceOf(Data::class)
+        fn ($instance) => expect($instance)->toBeInstanceOf(DummyData::class)
     );
 
     expect($collection)->toHaveCount(5);
@@ -36,7 +36,7 @@
 });
 
 it('can interact with data attributes', function () {
-    $data = new Data([
+    $data = new DummyData([
         0 => 'first',
         1 => '',
         'active' => 'true',
@@ -71,7 +71,7 @@
 });
 
 it('can retrieve data as enums', function () {
-    $data = new Data([
+    $data = new DummyData([
         'status' => 'active',
         'statuses' => ['active', 'inactive', 'missing'],
         'missing_status' => null,
@@ -144,7 +144,7 @@ public function __invoke(array $attributes): array
 it('can make a single instance after a count has been set', function () {
     $instance = FactoryStub::new()->count(5)->makeOne();
 
-    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance)->toBeInstanceOf(DummyData::class);
 });
 
 it('can make many instances from a number', function () {
diff --git a/tests/Fixtures/FactoryWithConfigurationStub.php b/tests/Fixtures/FactoryWithConfigurationStub.php
index 00aa700..549ddfc 100644
--- a/tests/Fixtures/FactoryWithConfigurationStub.php
+++ b/tests/Fixtures/FactoryWithConfigurationStub.php
@@ -2,7 +2,7 @@
 
 namespace DirectoryTree\Dummy\Tests\Fixtures;
 
-use DirectoryTree\Dummy\Data;
+use DirectoryTree\Dummy\DummyData;
 use DirectoryTree\Dummy\Factory;
 
 class FactoryWithConfigurationStub extends Factory
@@ -17,7 +17,7 @@ protected function definition(): array
 
     protected function configure(): static
     {
-        return $this->afterMaking(function (Data $data) {
+        return $this->afterMaking(function (DummyData $data) {
             $data->name = 'Custom';
         });
     }
diff --git a/tests/Fixtures/HasDummyFactoryDataStub.php b/tests/Fixtures/HasDummyFactoryDataStub.php
new file mode 100644
index 0000000..86f86eb
--- /dev/null
+++ b/tests/Fixtures/HasDummyFactoryDataStub.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace DirectoryTree\Dummy\Tests\Fixtures;
+
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\HasDummyFactory;
+use Faker\Generator;
+
+class HasDummyFactoryDataStub
+{
+    use HasDummyFactory;
+
+    protected static function toDummyInstance(DummyData $attributes): DummyData
+    {
+        return $attributes;
+    }
+
+    protected static function getDummyDefinition(Generator $faker): array
+    {
+        return [
+            'name' => $faker->name(),
+            'email' => $faker->email(),
+        ];
+    }
+}
diff --git a/tests/Fixtures/HasFactoryInstanceStub.php b/tests/Fixtures/HasDummyFactoryInstanceStub.php
similarity index 54%
rename from tests/Fixtures/HasFactoryInstanceStub.php
rename to tests/Fixtures/HasDummyFactoryInstanceStub.php
index b393d72..6e1c6cb 100644
--- a/tests/Fixtures/HasFactoryInstanceStub.php
+++ b/tests/Fixtures/HasDummyFactoryInstanceStub.php
@@ -2,24 +2,24 @@
 
 namespace DirectoryTree\Dummy\Tests\Fixtures;
 
-use DirectoryTree\Dummy\Data;
-use DirectoryTree\Dummy\HasFactory;
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\HasDummyFactory;
 use Faker\Generator;
 
-class HasFactoryInstanceStub
+class HasDummyFactoryInstanceStub
 {
-    use HasFactory;
+    use HasDummyFactory;
 
     public function __construct(
         public readonly array $attributes
     ) {}
 
-    protected static function toFactoryInstance(Data $attributes): self
+    protected static function toDummyInstance(DummyData $attributes): self
     {
         return new static($attributes->all());
     }
 
-    protected static function getFactoryDefinition(Generator $faker): array
+    protected static function getDummyDefinition(Generator $faker): array
     {
         return [
             'name' => $faker->name(),
diff --git a/tests/Fixtures/HasFactoryWithEloquentAttributesStub.php b/tests/Fixtures/HasDummyFactoryWithEloquentAttributesStub.php
similarity index 55%
rename from tests/Fixtures/HasFactoryWithEloquentAttributesStub.php
rename to tests/Fixtures/HasDummyFactoryWithEloquentAttributesStub.php
index 549b4bb..e22efbf 100644
--- a/tests/Fixtures/HasFactoryWithEloquentAttributesStub.php
+++ b/tests/Fixtures/HasDummyFactoryWithEloquentAttributesStub.php
@@ -2,20 +2,20 @@
 
 namespace DirectoryTree\Dummy\Tests\Fixtures;
 
-use DirectoryTree\Dummy\Data;
-use DirectoryTree\Dummy\HasFactory;
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\HasDummyFactory;
 use Faker\Generator;
 
-class HasFactoryWithEloquentAttributesStub
+class HasDummyFactoryWithEloquentAttributesStub
 {
-    use HasFactory;
+    use HasDummyFactory;
 
-    protected static function toFactoryInstance(Data $attributes): Data
+    protected static function toDummyInstance(DummyData $attributes): DummyData
     {
         return $attributes;
     }
 
-    protected static function getFactoryDefinition(Generator $faker): array
+    protected static function getDummyDefinition(Generator $faker): array
     {
         return [
             'model_id' => new EloquentModelStub(123),
diff --git a/tests/Fixtures/HasDummyFactoryWithReservedFactoryStub.php b/tests/Fixtures/HasDummyFactoryWithReservedFactoryStub.php
new file mode 100644
index 0000000..c9e9876
--- /dev/null
+++ b/tests/Fixtures/HasDummyFactoryWithReservedFactoryStub.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace DirectoryTree\Dummy\Tests\Fixtures;
+
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\HasDummyFactory;
+use Faker\Generator;
+
+class HasDummyFactoryWithReservedFactoryStub
+{
+    use HasDummyFactory;
+
+    public static function factory(): string
+    {
+        return 'reserved';
+    }
+
+    protected static function toDummyInstance(DummyData $attributes): DummyData
+    {
+        return $attributes;
+    }
+
+    protected static function getDummyDefinition(Generator $faker): array
+    {
+        return [
+            'name' => $faker->name(),
+            'email' => $faker->email(),
+        ];
+    }
+}
diff --git a/tests/Fixtures/HasFactoryWithStatesStub.php b/tests/Fixtures/HasDummyFactoryWithStatesStub.php
similarity index 76%
rename from tests/Fixtures/HasFactoryWithStatesStub.php
rename to tests/Fixtures/HasDummyFactoryWithStatesStub.php
index ed84782..ef90cf8 100644
--- a/tests/Fixtures/HasFactoryWithStatesStub.php
+++ b/tests/Fixtures/HasDummyFactoryWithStatesStub.php
@@ -2,13 +2,13 @@
 
 namespace DirectoryTree\Dummy\Tests\Fixtures;
 
-use DirectoryTree\Dummy\Data;
-use DirectoryTree\Dummy\HasFactory;
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\HasDummyFactory;
 use Faker\Generator;
 
-class HasFactoryWithStatesStub
+class HasDummyFactoryWithStatesStub
 {
-    use HasFactory;
+    use HasDummyFactory;
 
     /**
      * Admin state method.
@@ -43,12 +43,12 @@ public static function getPremiumState(): array
         ];
     }
 
-    protected static function toFactoryInstance(Data $attributes): Data
+    protected static function toDummyInstance(DummyData $attributes): DummyData
     {
         return $attributes;
     }
 
-    protected static function getFactoryDefinition(Generator $faker): array
+    protected static function getDummyDefinition(Generator $faker): array
     {
         return [
             'name' => $faker->name(),
diff --git a/tests/Fixtures/HasFactoryStub.php b/tests/Fixtures/HasFactoryStub.php
deleted file mode 100644
index be1627d..0000000
--- a/tests/Fixtures/HasFactoryStub.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?php
-
-namespace DirectoryTree\Dummy\Tests\Fixtures;
-
-use DirectoryTree\Dummy\Data;
-use DirectoryTree\Dummy\HasFactory;
-use Faker\Generator;
-
-class HasFactoryStub
-{
-    use HasFactory;
-
-    protected static function toFactoryInstance(Data $attributes): Data
-    {
-        return $attributes;
-    }
-
-    protected static function getFactoryDefinition(Generator $faker): array
-    {
-        return [
-            'name' => $faker->name(),
-            'email' => $faker->email(),
-        ];
-    }
-}
diff --git a/tests/HasFactoryTest.php b/tests/HasDummyFactoryTest.php
similarity index 50%
rename from tests/HasFactoryTest.php
rename to tests/HasDummyFactoryTest.php
index ef16f2a..2f29d09 100644
--- a/tests/HasFactoryTest.php
+++ b/tests/HasDummyFactoryTest.php
@@ -1,27 +1,38 @@
 <?php
 
-use DirectoryTree\Dummy\Data;
-use DirectoryTree\Dummy\Tests\Fixtures\HasFactoryInstanceStub;
-use DirectoryTree\Dummy\Tests\Fixtures\HasFactoryStub;
-use DirectoryTree\Dummy\Tests\Fixtures\HasFactoryWithStatesStub;
+use DirectoryTree\Dummy\DummyData;
+use DirectoryTree\Dummy\Tests\Fixtures\HasDummyFactoryDataStub;
+use DirectoryTree\Dummy\Tests\Fixtures\HasDummyFactoryInstanceStub;
+use DirectoryTree\Dummy\Tests\Fixtures\HasDummyFactoryWithReservedFactoryStub;
+use DirectoryTree\Dummy\Tests\Fixtures\HasDummyFactoryWithStatesStub;
 
 it('can generate fake data instance', function () {
-    $instance = HasFactoryStub::factory()->make();
+    $instance = HasDummyFactoryDataStub::dummy()->make();
 
-    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance)->toBeInstanceOf(DummyData::class);
     expect($instance->all())->toHaveKeys(['name', 'email']);
 });
 
 it('can overwrite fake data instance data', function () {
-    $instance = HasFactoryStub::factory()->make([
+    $instance = HasDummyFactoryDataStub::dummy()->make([
         'name' => 'John Doe',
     ]);
 
     expect($instance->name)->toBe('John Doe');
 });
 
+it('can generate fake data when factory is reserved by the target class', function () {
+    $instance = HasDummyFactoryWithReservedFactoryStub::dummy()->make([
+        'name' => 'John Doe',
+    ]);
+
+    expect(HasDummyFactoryWithReservedFactoryStub::factory())->toBe('reserved');
+    expect($instance)->toBeInstanceOf(DummyData::class);
+    expect($instance->name)->toBe('John Doe');
+});
+
 it('passes data into the factory instance transformer', function () {
-    $instance = HasFactoryInstanceStub::factory([
+    $instance = HasDummyFactoryInstanceStub::dummy([
         'active' => 'true',
         'visits' => '5',
     ])->make();
@@ -32,25 +43,25 @@
 });
 
 it('can generate fake instance of self', function () {
-    $instance = HasFactoryInstanceStub::factory()->make();
+    $instance = HasDummyFactoryInstanceStub::dummy()->make();
 
-    expect($instance)->toBeInstanceOf(HasFactoryInstanceStub::class);
+    expect($instance)->toBeInstanceOf(HasDummyFactoryInstanceStub::class);
     expect($instance->attributes)->toHaveKeys(['name', 'email']);
 });
 
 it('can use dynamic state methods', function () {
-    $instance = HasFactoryWithStatesStub::factory()->admin()->make();
+    $instance = HasDummyFactoryWithStatesStub::dummy()->admin()->make();
 
-    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance)->toBeInstanceOf(DummyData::class);
     expect($instance->role)->toBe('admin');
     expect($instance->name)->toBe('Admin User');
     expect($instance->email)->toBe('admin@example.com');
 });
 
 it('can chain multiple dynamic state methods', function () {
-    $instance = HasFactoryWithStatesStub::factory()->admin()->inactive()->make();
+    $instance = HasDummyFactoryWithStatesStub::dummy()->admin()->inactive()->make();
 
-    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance)->toBeInstanceOf(DummyData::class);
     expect($instance->role)->toBe('admin');
     expect($instance->name)->toBe('Admin User');
     expect($instance->email)->toBe('admin@example.com');
@@ -58,15 +69,15 @@
 });
 
 it('can use dynamic state methods with premium state', function () {
-    $instance = HasFactoryWithStatesStub::factory()->premium()->make();
+    $instance = HasDummyFactoryWithStatesStub::dummy()->premium()->make();
 
-    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance)->toBeInstanceOf(DummyData::class);
     expect($instance->role)->toBe('premium');
     expect($instance->subscription)->toBe('premium');
 });
 
 it('throws exception for non-existent state methods', function () {
     expect(function () {
-        HasFactoryWithStatesStub::factory()->nonExistentState()->make();
+        HasDummyFactoryWithStatesStub::dummy()->nonExistentState()->make();
     })->toThrow(BadMethodCallException::class);
 });