diff --git a/src/DataModel/Configuration/GameConfiguration.cs b/src/DataModel/Configuration/GameConfiguration.cs
index 6dc0b7d18..3d87ad5bb 100644
--- a/src/DataModel/Configuration/GameConfiguration.cs
+++ b/src/DataModel/Configuration/GameConfiguration.cs
@@ -265,6 +265,18 @@ public partial class GameConfiguration
     [MemberOfAggregate]
     public virtual ICollection<MasterSkillRoot> MasterSkillRoots { get; protected set; } = null!;
 
+    /// <summary>
+    /// Gets or sets the attribute combinations.
+    /// </summary>
+    [MemberOfAggregate]
+    public virtual ICollection<AttributeRelationship> GlobalAttributeCombinations { get; protected set; } = null!;
+
+    /// <summary>
+    /// Gets or sets the base attribute values.
+    /// </summary>
+    [MemberOfAggregate]
+    public virtual ICollection<ConstValueAttribute> GlobalBaseAttributeValues { get; protected set; } = null!;
+
     /// <summary>
     /// Gets or sets the plug in configurations.
     /// </summary>
diff --git a/src/DataModel/GameConfigurationHelper.cs b/src/DataModel/GameConfigurationHelper.cs
index 9a5a03a86..dc9e1bae7 100644
--- a/src/DataModel/GameConfigurationHelper.cs
+++ b/src/DataModel/GameConfigurationHelper.cs
@@ -57,8 +57,12 @@ public static class GameConfigurationHelper
         {
             typeof(AttributeRelationship), c => c.CharacterClasses.SelectMany(a => a.AttributeCombinations)
                 .Concat(Enumerables![typeof(PowerUpDefinitionValue)](c).OfType<PowerUpDefinitionValue>().SelectMany(v => v.RelatedValues))
+                .Concat(c.GlobalAttributeCombinations)
+        },
+        {
+            typeof(ConstValueAttribute), c => c.CharacterClasses.SelectMany(a => a.BaseAttributeValues)
+                .Concat(c.GlobalBaseAttributeValues)
         },
-        { typeof(ConstValueAttribute), c => c.CharacterClasses.SelectMany(a => a.BaseAttributeValues) },
         { typeof(SkillComboDefinition), c => c.CharacterClasses.Select(a => a.ComboDefinition).WhereNotNull() },
         { typeof(SkillComboStep), c => c.CharacterClasses.Select(a => a.ComboDefinition).WhereNotNull().SelectMany(d => d.Steps) },
         { typeof(DropItemGroup), c => c.DropItemGroups },
diff --git a/src/GameLogic/Attributes/ItemAwareAttributeSystem.cs b/src/GameLogic/Attributes/ItemAwareAttributeSystem.cs
index 3a72a8816..0f9dc1d52 100644
--- a/src/GameLogic/Attributes/ItemAwareAttributeSystem.cs
+++ b/src/GameLogic/Attributes/ItemAwareAttributeSystem.cs
@@ -5,6 +5,7 @@
 namespace MUnique.OpenMU.GameLogic.Attributes;
 
 using MUnique.OpenMU.AttributeSystem;
+using MUnique.OpenMU.DataModel.Configuration;
 
 /// <summary>
 /// An attribute system which considers items of a character.
@@ -16,11 +17,12 @@ public sealed class ItemAwareAttributeSystem : AttributeSystem, IDisposable
     /// </summary>
     /// <param name="account">The account.</param>
     /// <param name="character">The character.</param>
-    public ItemAwareAttributeSystem(Account account, Character character)
+    /// <param name="gameConfiguration">The game configuration with global attributes.</param>
+    public ItemAwareAttributeSystem(Account account, Character character, GameConfiguration gameConfiguration)
         : base(
             character.Attributes.Concat(account.Attributes),
-            character.CharacterClass!.BaseAttributeValues,
-            character.CharacterClass.AttributeCombinations)
+            character.CharacterClass!.BaseAttributeValues.Concat(gameConfiguration.GlobalBaseAttributeValues),
+            character.CharacterClass.AttributeCombinations.Concat(gameConfiguration.GlobalAttributeCombinations))
     {
         this.ItemPowerUps = new Dictionary<Item, IReadOnlyList<PowerUpWrapper>>();
         foreach (var attribute in this)
diff --git a/src/GameLogic/Player.cs b/src/GameLogic/Player.cs
index d38609f1b..ad425c8b8 100644
--- a/src/GameLogic/Player.cs
+++ b/src/GameLogic/Player.cs
@@ -2392,7 +2392,7 @@ private async ValueTask OnPlayerEnteredWorldAsync()
         selectedCharacter.CurrentMap ??= selectedCharacter.CharacterClass?.HomeMap;
         this.AddMissingStatAttributes();
 
-        this.Attributes = new ItemAwareAttributeSystem(this.Account!, selectedCharacter);
+        this.Attributes = new ItemAwareAttributeSystem(this.Account!, selectedCharacter, this.GameContext.Configuration);
         this.Attributes[Stats.NearbyPartyMemberCount] = 0;
         this.LogInvalidInventoryItems();
 
diff --git a/src/Persistence/BasicModel/GameConfiguration.Generated.cs b/src/Persistence/BasicModel/GameConfiguration.Generated.cs
index b0ee96b81..9460cd4f0 100644
--- a/src/Persistence/BasicModel/GameConfiguration.Generated.cs
+++ b/src/Persistence/BasicModel/GameConfiguration.Generated.cs
@@ -382,6 +382,48 @@ protected set
         }
     }
 
+    /// <summary>
+    /// Gets the raw collection of <see cref="GlobalAttributeCombinations" />.
+    /// </summary>
+    [System.Text.Json.Serialization.JsonPropertyName("globalAttributeCombinations")]
+    public ICollection<AttributeRelationship> RawGlobalAttributeCombinations { get; } = new List<AttributeRelationship>();
+    
+    /// <inheritdoc/>
+    [System.Text.Json.Serialization.JsonIgnore]
+    public override ICollection<MUnique.OpenMU.AttributeSystem.AttributeRelationship> GlobalAttributeCombinations
+    {
+        get => base.GlobalAttributeCombinations ??= new CollectionAdapter<MUnique.OpenMU.AttributeSystem.AttributeRelationship, AttributeRelationship>(this.RawGlobalAttributeCombinations);
+        protected set
+        {
+            this.GlobalAttributeCombinations.Clear();
+            foreach (var item in value)
+            {
+                this.GlobalAttributeCombinations.Add(item);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets the raw collection of <see cref="GlobalBaseAttributeValues" />.
+    /// </summary>
+    [System.Text.Json.Serialization.JsonPropertyName("globalBaseAttributeValues")]
+    public ICollection<ConstValueAttribute> RawGlobalBaseAttributeValues { get; } = new List<ConstValueAttribute>();
+    
+    /// <inheritdoc/>
+    [System.Text.Json.Serialization.JsonIgnore]
+    public override ICollection<MUnique.OpenMU.AttributeSystem.ConstValueAttribute> GlobalBaseAttributeValues
+    {
+        get => base.GlobalBaseAttributeValues ??= new CollectionAdapter<MUnique.OpenMU.AttributeSystem.ConstValueAttribute, ConstValueAttribute>(this.RawGlobalBaseAttributeValues);
+        protected set
+        {
+            this.GlobalBaseAttributeValues.Clear();
+            foreach (var item in value)
+            {
+                this.GlobalBaseAttributeValues.Add(item);
+            }
+        }
+    }
+
     /// <summary>
     /// Gets the raw collection of <see cref="PlugInConfigurations" />.
     /// </summary>
diff --git a/src/Persistence/EntityFramework/CachingRepositoryProvider.cs b/src/Persistence/EntityFramework/CachingRepositoryProvider.cs
index 46591978d..038830074 100644
--- a/src/Persistence/EntityFramework/CachingRepositoryProvider.cs
+++ b/src/Persistence/EntityFramework/CachingRepositoryProvider.cs
@@ -63,6 +63,8 @@ protected override void Initialize()
             this.LoggerFactory,
             config => config.RawItemOptions.SelectMany(o => o.RawPossibleOptions).Distinct().ToList()));
         this.RegisterRepository(new ConfigurationTypeRepository<AttributeDefinition>(this._parent, this.LoggerFactory, config => config.RawAttributes));
+        this.RegisterRepository(new ConfigurationTypeRepository<AttributeRelationship>(this._parent, this.LoggerFactory, config => config.RawGlobalAttributeCombinations));
+        this.RegisterRepository(new ConfigurationTypeRepository<ConstValueAttribute>(this._parent, this.LoggerFactory, config => config.RawGlobalBaseAttributeValues));
         this.RegisterRepository(new ConfigurationTypeRepository<DropItemGroup>(this._parent, this.LoggerFactory, config => config.RawDropItemGroups));
         this.RegisterRepository(new ConfigurationTypeRepository<CharacterClass>(this._parent, this.LoggerFactory, config => config.RawCharacterClasses));
         this.RegisterRepository(new ConfigurationTypeRepository<ItemOptionType>(this._parent, this.LoggerFactory, config => config.RawItemOptionTypes));
diff --git a/src/Persistence/EntityFramework/Extensions/ModelBuilder/CharacterExtensions.cs b/src/Persistence/EntityFramework/Extensions/ModelBuilder/CharacterExtensions.cs
index 46ed821e2..4bb19ff17 100644
--- a/src/Persistence/EntityFramework/Extensions/ModelBuilder/CharacterExtensions.cs
+++ b/src/Persistence/EntityFramework/Extensions/ModelBuilder/CharacterExtensions.cs
@@ -39,6 +39,6 @@ public static void Apply(this EntityTypeBuilder<CharacterClass> builder)
     {
         builder.Property(p => p.Name).HasConversion(LocalizedStringConverter.Instance);
         builder.HasMany(c => c.RawBaseAttributeValues)
-            .WithOne(c => c.CharacterClass!);
+            .WithOne(c => c.CharacterClass);
     }
 }
\ No newline at end of file
diff --git a/src/Persistence/EntityFramework/Extensions/ModelBuilder/GameConfigurationExtensions.cs b/src/Persistence/EntityFramework/Extensions/ModelBuilder/GameConfigurationExtensions.cs
index 1ee750ea0..d6782254a 100644
--- a/src/Persistence/EntityFramework/Extensions/ModelBuilder/GameConfigurationExtensions.cs
+++ b/src/Persistence/EntityFramework/Extensions/ModelBuilder/GameConfigurationExtensions.cs
@@ -22,6 +22,7 @@ public static void Apply(this EntityTypeBuilder<GameConfiguration> builder)
         builder.Property(c => c.ItemDropDuration).HasDefaultValue(TimeSpan.FromSeconds(60));
         builder.Property(c => c.ExperienceFormula).HasDefaultValue("if(level == 0, 0, if(level < 256, 10 * (level + 8) * (level - 1) * (level - 1), (10 * (level + 8) * (level - 1) * (level - 1)) + (1000 * (level - 247) * (level - 256) * (level - 256))))");
         builder.Property(c => c.MasterExperienceFormula).HasDefaultValue("(505 * level * level * level) + (35278500 * level) + (228045 * level * level)");
+        builder.HasMany(c => c.RawGlobalBaseAttributeValues).WithOne(c => c.GameConfiguration);
     }
 
     /// <summary>
diff --git a/src/Persistence/EntityFramework/Migrations/20260320211230_AddGlobalAttributes.Designer.cs b/src/Persistence/EntityFramework/Migrations/20260320211230_AddGlobalAttributes.Designer.cs
new file mode 100644
index 000000000..3968dd1e4
--- /dev/null
+++ b/src/Persistence/EntityFramework/Migrations/20260320211230_AddGlobalAttributes.Designer.cs
@@ -0,0 +1,5220 @@
+// <auto-generated />
+using System;
+using MUnique.OpenMU.Persistence.EntityFramework;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MUnique.OpenMU.Persistence.EntityFramework.Migrations
+{
+    [DbContext(typeof(EntityDataContext))]
+    [Migration("20260320211230_AddGlobalAttributes")]
+    partial class AddGlobalAttributes
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.2")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("ChatBanUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EMail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsTemplate")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsVaultExtended")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LanguageIsoCode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("character varying(3)")
+                        .HasDefaultValue("en");
+
+                    b.Property<string>("LoginName")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("RegistrationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("SecurityCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.Property<short>("TimeZone")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("VaultId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("VaultPassword")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LoginName")
+                        .IsUnique();
+
+                    b.HasIndex("VaultId")
+                        .IsUnique();
+
+                    b.ToTable("Account", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AccountCharacterClass", b =>
+                {
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CharacterClassId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("AccountId", "CharacterClassId");
+
+                    b.HasIndex("CharacterClassId");
+
+                    b.ToTable("AccountCharacterClass", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AppearanceData", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CharacterClassId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("FullAncientSetEquipped")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("Pose")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterClassId");
+
+                    b.ToTable("AppearanceData", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AreaSkillSettings", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeSpan>("DelayBetweenHits")
+                        .HasColumnType("interval");
+
+                    b.Property<TimeSpan>("DelayPerOneDistance")
+                        .HasColumnType("interval");
+
+                    b.Property<float>("FrustumDistance")
+                        .HasColumnType("real");
+
+                    b.Property<float>("FrustumEndWidth")
+                        .HasColumnType("real");
+
+                    b.Property<float>("FrustumStartWidth")
+                        .HasColumnType("real");
+
+                    b.Property<float>("HitChancePerDistanceMultiplier")
+                        .HasColumnType("real");
+
+                    b.Property<int>("MaximumNumberOfHitsPerAttack")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumNumberOfHitsPerTarget")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinimumNumberOfHitsPerTarget")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProjectileCount")
+                        .HasColumnType("integer");
+
+                    b.Property<float>("TargetAreaDiameter")
+                        .HasColumnType("real");
+
+                    b.Property<bool>("UseDeferredHits")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("UseFrustumFilter")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("UseTargetAreaFilter")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AreaSkillSettings", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Designation")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<float?>("MaximumValue")
+                        .HasColumnType("real");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("AttributeDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeRelationship", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AggregateType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("CharacterClassId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("InputAttributeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<float>("InputOperand")
+                        .HasColumnType("real");
+
+                    b.Property<int>("InputOperator")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("OperandAttributeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PowerUpDefinitionValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("SkillId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TargetAttributeId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterClassId");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("InputAttributeId");
+
+                    b.HasIndex("OperandAttributeId");
+
+                    b.HasIndex("PowerUpDefinitionValueId");
+
+                    b.HasIndex("SkillId");
+
+                    b.HasIndex("TargetAttributeId");
+
+                    b.ToTable("AttributeRelationship", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeRequirement", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AttributeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameMapDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MinimumValue")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SkillId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("SkillId1")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AttributeId");
+
+                    b.HasIndex("GameMapDefinitionId");
+
+                    b.HasIndex("ItemDefinitionId");
+
+                    b.HasIndex("SkillId");
+
+                    b.HasIndex("SkillId1");
+
+                    b.ToTable("AttributeRequirement", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.BattleZoneDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GroundId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("LeftGoalId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte?>("LeftTeamSpawnPointX")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("LeftTeamSpawnPointY")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("RightGoalId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte?>("RightTeamSpawnPointX")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("RightTeamSpawnPointY")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroundId")
+                        .IsUnique();
+
+                    b.HasIndex("LeftGoalId")
+                        .IsUnique();
+
+                    b.HasIndex("RightGoalId")
+                        .IsUnique();
+
+                    b.ToTable("BattleZoneDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CharacterClassId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("CharacterSlot")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("CharacterStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreateDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("CurrentMapId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("Experience")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("InventoryExtensions")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("InventoryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsStoreOpened")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte[]>("KeyConfiguration")
+                        .HasColumnType("bytea");
+
+                    b.Property<int>("LevelUpPoints")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("MasterExperience")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("MasterLevelUpPoints")
+                        .HasColumnType("integer");
+
+                    b.Property<byte[]>("MuHelperConfiguration")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<int>("PlayerKillCount")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("Pose")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("PositionX")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("PositionY")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StateRemainingSeconds")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("StoreName")
+                        .HasColumnType("text");
+
+                    b.Property<int>("UsedFruitPoints")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UsedNegFruitPoints")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CharacterClassId");
+
+                    b.HasIndex("CurrentMapId");
+
+                    b.HasIndex("InventoryId")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Character", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("CanGetCreated")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ComboDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("CreationAllowedFlag")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("FruitCalculation")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("HomeMapId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsMasterClass")
+                        .HasColumnType("boolean");
+
+                    b.Property<short>("LevelRequirementByCreation")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("LevelWarpRequirementReductionPercent")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("NextGenerationClassId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("Number")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ComboDefinitionId")
+                        .IsUnique();
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("HomeMapId");
+
+                    b.HasIndex("NextGenerationClassId");
+
+                    b.ToTable("CharacterClass", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterDropItemGroup", b =>
+                {
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("DropItemGroupId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("CharacterId", "DropItemGroupId");
+
+                    b.HasIndex("DropItemGroupId");
+
+                    b.ToTable("CharacterDropItemGroup", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterQuestState", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ActiveQuestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CharacterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("ClientActionPerformed")
+                        .HasColumnType("boolean");
+
+                    b.Property<short>("Group")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("LastFinishedQuestId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActiveQuestId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("LastFinishedQuestId");
+
+                    b.ToTable("CharacterQuestState", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ChatServerDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeSpan>("ClientCleanUpInterval")
+                        .HasColumnType("interval");
+
+                    b.Property<TimeSpan>("ClientTimeout")
+                        .HasColumnType("interval");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("MaximumConnections")
+                        .HasColumnType("integer");
+
+                    b.Property<TimeSpan>("RoomCleanUpInterval")
+                        .HasColumnType("interval");
+
+                    b.Property<byte>("ServerId")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChatServerDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ChatServerEndpoint", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ChatServerDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ClientId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("NetworkPort")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChatServerDefinitionId");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("ChatServerEndpoint", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CombinationBonusRequirement", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemOptionCombinationBonusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MinimumCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("OptionTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("SubOptionType")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemOptionCombinationBonusId");
+
+                    b.HasIndex("OptionTypeId");
+
+                    b.ToTable("CombinationBonusRequirement", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ConfigurationUpdate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("InstalledAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ConfigurationUpdate", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ConfigurationUpdateState", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CurrentInstalledVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("InitializationKey")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ConfigurationUpdateState", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ConnectServerDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("CheckMaxConnectionsPerAddress")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ClientId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ClientListenerPort")
+                        .HasColumnType("integer");
+
+                    b.Property<byte[]>("CurrentPatchVersion")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("DisconnectOnUnknownPacket")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("ListenerBacklog")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxConnections")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxConnectionsPerAddress")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxFtpRequests")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxIpRequests")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxServerListRequests")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("MaximumReceiveSize")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("PatchAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("ServerId")
+                        .HasColumnType("smallint");
+
+                    b.Property<TimeSpan>("Timeout")
+                        .HasColumnType("interval");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("ConnectServerDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ConstValueAttribute", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CharacterClassId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<float>("Value")
+                        .HasColumnType("real");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterClassId");
+
+                    b.HasIndex("DefinitionId");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("ConstValueAttribute", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Chance")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte?>("ItemLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("ItemType")
+                        .HasColumnType("integer");
+
+                    b.Property<byte?>("MaximumMonsterLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte?>("MinimumMonsterLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("MonsterId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("MonsterId");
+
+                    b.ToTable("DropItemGroup", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroupItemDefinition", b =>
+                {
+                    b.Property<Guid>("DropItemGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("DropItemGroupId", "ItemDefinitionId");
+
+                    b.HasIndex("ItemDefinitionId");
+
+                    b.ToTable("DropItemGroupItemDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DuelArea", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DuelConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("FirstPlayerGateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<short>("Index")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("SecondPlayerGateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("SpectatorsGateId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DuelConfigurationId");
+
+                    b.HasIndex("FirstPlayerGateId");
+
+                    b.HasIndex("SecondPlayerGateId");
+
+                    b.HasIndex("SpectatorsGateId");
+
+                    b.ToTable("DuelArea", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DuelConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("EntranceFee")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ExitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MaximumScore")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumSpectatorsPerDuelRoom")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinimumCharacterLevel")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExitId");
+
+                    b.ToTable("DuelConfiguration", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.EnterGate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameMapDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<short>("LevelRequirement")
+                        .HasColumnType("smallint");
+
+                    b.Property<short>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("TargetGateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("X1")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("X2")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Y1")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Y2")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameMapDefinitionId");
+
+                    b.HasIndex("TargetGateId");
+
+                    b.ToTable("EnterGate", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Direction")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsSpawnGate")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("MapId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("X1")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("X2")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Y1")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Y2")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MapId");
+
+                    b.ToTable("ExitGate", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Friend", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Accepted")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FriendId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("RequestOpen")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasAlternateKey("CharacterId", "FriendId");
+
+                    b.ToTable("Friend", "friend");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameClientDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Episode")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("Language")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("Season")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte[]>("Serial")
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("Version")
+                        .HasColumnType("bytea");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GameClientDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("AreaSkillHitsPlayer")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("CharacterNameRegex")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("ClampMoneyOnPickup")
+                        .HasColumnType("boolean");
+
+                    b.Property<double>("DamagePerOneItemDurability")
+                        .HasColumnType("double precision");
+
+                    b.Property<double>("DamagePerOnePetDurability")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid?>("DuelConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ExperienceFormula")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text")
+                        .HasDefaultValue("if(level == 0, 0, if(level < 256, 10 * (level + 8) * (level - 1) * (level - 1), (10 * (level + 8) * (level - 1) * (level - 1)) + (1000 * (level - 247) * (level - 256) * (level - 256))))");
+
+                    b.Property<float>("ExperienceRate")
+                        .HasColumnType("real");
+
+                    b.Property<double>("HitsPerOneItemDurability")
+                        .HasColumnType("double precision");
+
+                    b.Property<byte>("InfoRange")
+                        .HasColumnType("smallint");
+
+                    b.Property<TimeSpan>("ItemDropDuration")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("interval")
+                        .HasDefaultValue(new TimeSpan(0, 0, 1, 0, 0));
+
+                    b.Property<int>("LetterSendPrice")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterExperienceFormula")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text")
+                        .HasDefaultValue("(505 * level * level * level) + (35278500 * level) + (228045 * level * level)");
+
+                    b.Property<byte>("MaximumCharactersPerAccount")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("MaximumInventoryMoney")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("MaximumItemOptionLevelDrop")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("MaximumLetters")
+                        .HasColumnType("integer");
+
+                    b.Property<short>("MaximumLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<short>("MaximumMasterLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("MaximumPartySize")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("MaximumPasswordLength")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumVaultMoney")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("MinimumMonsterLevelForMasterExperience")
+                        .HasColumnType("smallint");
+
+                    b.Property<bool>("PreventExperienceOverflow")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("RecoveryInterval")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("ShouldDropMoney")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DuelConfigurationId")
+                        .IsUnique();
+
+                    b.ToTable("GameConfiguration", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("BattleZoneId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Discriminator")
+                        .HasColumnType("integer");
+
+                    b.Property<double>("ExpMultiplier")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<short>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("SafezoneMapId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte[]>("TerrainData")
+                        .HasColumnType("bytea");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BattleZoneId")
+                        .IsUnique();
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("SafezoneMapId");
+
+                    b.ToTable("GameMapDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinitionDropItemGroup", b =>
+                {
+                    b.Property<Guid>("GameMapDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("DropItemGroupId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("GameMapDefinitionId", "DropItemGroupId");
+
+                    b.HasIndex("DropItemGroupId");
+
+                    b.ToTable("GameMapDefinitionDropItemGroup", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<short>("MaximumPlayers")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GameServerConfiguration", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerConfigurationGameMapDefinition", b =>
+                {
+                    b.Property<Guid>("GameServerConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("GameMapDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("GameServerConfigurationId", "GameMapDefinitionId");
+
+                    b.HasIndex("GameMapDefinitionId");
+
+                    b.ToTable("GameServerConfigurationGameMapDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float>("ExperienceRate")
+                        .HasColumnType("real");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("PvpEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(true);
+
+                    b.Property<Guid?>("ServerConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("ServerID")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("ServerConfigurationId");
+
+                    b.ToTable("GameServerDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerEndpoint", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AlternativePublishedPort")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ClientId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameServerDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("NetworkPort")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("GameServerDefinitionId");
+
+                    b.ToTable("GameServerEndpoint", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Guild", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AllianceGuildId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("HostilityId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte[]>("Logo")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Notice")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Score")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AllianceGuildId");
+
+                    b.HasIndex("HostilityId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Guild", "guild");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GuildMember", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("GuildId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("Status")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId");
+
+                    b.ToTable("GuildMember", "guild");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.IncreasableItemOption", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemOptionDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("LevelType")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Number")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("OptionTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PowerUpDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("SubOptionType")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("Weight")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemOptionDefinitionId");
+
+                    b.HasIndex("OptionTypeId");
+
+                    b.HasIndex("PowerUpDefinitionId")
+                        .IsUnique();
+
+                    b.ToTable("IncreasableItemOption", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Item", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Durability")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("HasSkill")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("ItemSlot")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("ItemStorageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("Level")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("PetExperience")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SocketCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("StorePrice")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DefinitionId");
+
+                    b.HasIndex("ItemStorageId");
+
+                    b.ToTable("Item", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemAppearance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AppearanceDataId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("ItemSlot")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Level")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AppearanceDataId");
+
+                    b.HasIndex("DefinitionId");
+
+                    b.ToTable("ItemAppearance", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemAppearanceItemOptionType", b =>
+                {
+                    b.Property<Guid>("ItemAppearanceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ItemOptionTypeId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("ItemAppearanceId", "ItemOptionTypeId");
+
+                    b.HasIndex("ItemOptionTypeId");
+
+                    b.ToTable("ItemAppearanceItemOptionType", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemBasePowerUpDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AggregateType")
+                        .HasColumnType("integer");
+
+                    b.Property<float>("BaseValue")
+                        .HasColumnType("real");
+
+                    b.Property<Guid?>("BonusPerLevelTableId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TargetAttributeId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BonusPerLevelTableId");
+
+                    b.HasIndex("ItemDefinitionId");
+
+                    b.HasIndex("TargetAttributeId");
+
+                    b.ToTable("ItemBasePowerUpDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCrafting", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ItemCraftingHandlerClassName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("MonsterDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("SimpleCraftingSettingsId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MonsterDefinitionId");
+
+                    b.HasIndex("SimpleCraftingSettingsId")
+                        .IsUnique();
+
+                    b.ToTable("ItemCrafting", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("AddPercentage")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("FailResult")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("MaximumAmount")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("MaximumItemLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("MinimumAmount")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("MinimumItemLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("NpcPriceDivisor")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("Reference")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("SimpleCraftingSettingsId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("SuccessResult")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SimpleCraftingSettingsId");
+
+                    b.ToTable("ItemCraftingRequiredItem", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItemItemDefinition", b =>
+                {
+                    b.Property<Guid>("ItemCraftingRequiredItemId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("ItemCraftingRequiredItemId", "ItemDefinitionId");
+
+                    b.HasIndex("ItemDefinitionId");
+
+                    b.ToTable("ItemCraftingRequiredItemItemDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItemItemOptionType", b =>
+                {
+                    b.Property<Guid>("ItemCraftingRequiredItemId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ItemOptionTypeId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("ItemCraftingRequiredItemId", "ItemOptionTypeId");
+
+                    b.HasIndex("ItemOptionTypeId");
+
+                    b.ToTable("ItemCraftingRequiredItemItemOptionType", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingResultItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("AddLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte?>("Durability")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("RandomMaximumLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("RandomMinimumLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Reference")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("SimpleCraftingSettingsId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemDefinitionId");
+
+                    b.HasIndex("SimpleCraftingSettingsId");
+
+                    b.ToTable("ItemCraftingResultItem", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ConsumeEffectId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("DropLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<bool>("DropsFromMonsters")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("Durability")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("Group")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Height")
+                        .HasColumnType("smallint");
+
+                    b.Property<bool>("IsAmmunition")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsBoundToCharacter")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ItemSlotId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("MaximumItemLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("MaximumSockets")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<short>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("PetExperienceFormula")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("SkillId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("StorageLimitPerCharacter")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("Width")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConsumeEffectId");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("ItemSlotId");
+
+                    b.HasIndex("SkillId");
+
+                    b.ToTable("ItemDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinitionCharacterClass", b =>
+                {
+                    b.Property<Guid>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CharacterClassId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("ItemDefinitionId", "CharacterClassId");
+
+                    b.HasIndex("CharacterClassId");
+
+                    b.ToTable("ItemDefinitionCharacterClass", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinitionItemOptionDefinition", b =>
+                {
+                    b.Property<Guid>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ItemOptionDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("ItemDefinitionId", "ItemOptionDefinitionId");
+
+                    b.HasIndex("ItemOptionDefinitionId");
+
+                    b.ToTable("ItemDefinitionItemOptionDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinitionItemSetGroup", b =>
+                {
+                    b.Property<Guid>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ItemSetGroupId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("ItemDefinitionId", "ItemSetGroupId");
+
+                    b.HasIndex("ItemSetGroupId");
+
+                    b.ToTable("ItemDefinitionItemSetGroup", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDropItemGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Chance")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("DropEffect")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte?>("ItemLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("ItemType")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("MaximumLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte?>("MaximumMonsterLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("MinimumLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte?>("MinimumMonsterLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("MoneyAmount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("MonsterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<short>("RequiredCharacterLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("SourceItemLevel")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemDefinitionId");
+
+                    b.HasIndex("MonsterId");
+
+                    b.ToTable("ItemDropItemGroup", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDropItemGroupItemDefinition", b =>
+                {
+                    b.Property<Guid>("ItemDropItemGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("ItemDropItemGroupId", "ItemDefinitionId");
+
+                    b.HasIndex("ItemDefinitionId");
+
+                    b.ToTable("ItemDropItemGroupItemDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemItemOfItemSet", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ItemOfItemSetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("ItemId", "ItemOfItemSetId");
+
+                    b.HasIndex("ItemOfItemSetId");
+
+                    b.ToTable("ItemItemOfItemSet", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemLevelBonusTable", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("ItemLevelBonusTable", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOfItemSet", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AncientSetDiscriminator")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("BonusOptionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemSetGroupId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BonusOptionId");
+
+                    b.HasIndex("ItemDefinitionId");
+
+                    b.HasIndex("ItemSetGroupId");
+
+                    b.ToTable("ItemOfItemSet", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOption", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Number")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("OptionTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PowerUpDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("SubOptionType")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OptionTypeId");
+
+                    b.HasIndex("PowerUpDefinitionId")
+                        .IsUnique();
+
+                    b.ToTable("ItemOption", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionCombinationBonus", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("AppliesMultipleTimes")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("BonusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Number")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BonusId")
+                        .IsUnique();
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("ItemOptionCombinationBonus", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<float>("AddChance")
+                        .HasColumnType("real");
+
+                    b.Property<bool>("AddsRandomly")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MaximumOptionsPerItem")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("ItemOptionDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ItemId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemOptionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ItemOptionId");
+
+                    b.ToTable("ItemOptionLink", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionOfLevel", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("IncreasableItemOptionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PowerUpDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("RequiredItemLevel")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IncreasableItemOptionId");
+
+                    b.HasIndex("PowerUpDefinitionId")
+                        .IsUnique();
+
+                    b.ToTable("ItemOptionOfLevel", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsVisible")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("ItemOptionType", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemSetGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("AlwaysApplies")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("CountDistinct")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MinimumItemCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("OptionsId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("SetLevel")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("OptionsId");
+
+                    b.ToTable("ItemSetGroup", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemSlotType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RawItemSlots")
+                        .HasColumnType("text")
+                        .HasColumnName("ItemSlots")
+                        .HasJsonPropertyName("itemSlots");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("ItemSlotType", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemStorage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Money")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ItemStorage", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.JewelMix", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MixedJewelId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("SingleJewelId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("MixedJewelId");
+
+                    b.HasIndex("SingleJewelId");
+
+                    b.ToTable("JewelMix", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.LetterBody", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("Animation")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("HeaderId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Rotation")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("SenderAppearanceId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HeaderId");
+
+                    b.HasIndex("SenderAppearanceId")
+                        .IsUnique();
+
+                    b.ToTable("LetterBody", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.LetterHeader", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LetterDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("ReadFlag")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("ReceiverId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("SenderName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subject")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReceiverId");
+
+                    b.ToTable("LetterHeader", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.LevelBonus", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<float>("AdditionalValue")
+                        .HasColumnType("real");
+
+                    b.Property<Guid?>("ItemLevelBonusTableId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemLevelBonusTableId");
+
+                    b.ToTable("LevelBonus", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ChanceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ChancePvpId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("DurationDependsOnTargetLevel")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("DurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DurationPvpId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("InformObservers")
+                        .HasColumnType("boolean");
+
+                    b.Property<float>("MonsterTargetLevelDivisor")
+                        .HasColumnType("real");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<short>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<float>("PlayerTargetLevelDivisor")
+                        .HasColumnType("real");
+
+                    b.Property<bool>("SendDuration")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("StopByDeath")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("SubType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChanceId")
+                        .IsUnique();
+
+                    b.HasIndex("ChancePvpId")
+                        .IsUnique();
+
+                    b.HasIndex("DurationId")
+                        .IsUnique();
+
+                    b.HasIndex("DurationPvpId")
+                        .IsUnique();
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("MagicEffectDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Aggregation")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("DisplayValueFormula")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("ExtendsDuration")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("MaximumLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("MinimumLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Rank")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("ReplacedSkillId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("RootId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TargetAttributeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ValueFormula")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReplacedSkillId");
+
+                    b.HasIndex("RootId");
+
+                    b.HasIndex("TargetAttributeId");
+
+                    b.ToTable("MasterSkillDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillDefinitionSkill", b =>
+                {
+                    b.Property<Guid>("MasterSkillDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("SkillId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("MasterSkillDefinitionId", "SkillId");
+
+                    b.HasIndex("SkillId");
+
+                    b.ToTable("MasterSkillDefinitionSkill", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillRoot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("MasterSkillRoot", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameChangeEvent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("MiniGameDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<short?>("MinimumTargetLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<bool>("MultiplyKillsByPlayers")
+                        .HasColumnType("boolean");
+
+                    b.Property<short>("NumberOfKills")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("SpawnAreaId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Target")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TargetDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MiniGameDefinitionId");
+
+                    b.HasIndex("SpawnAreaId")
+                        .IsUnique();
+
+                    b.HasIndex("TargetDefinitionId");
+
+                    b.ToTable("MiniGameChangeEvent", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("AllowParty")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("ArePlayerKillersAllowedToEnter")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<TimeSpan>("EnterDuration")
+                        .HasColumnType("interval");
+
+                    b.Property<int>("EntranceFee")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("EntranceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeSpan>("ExitDuration")
+                        .HasColumnType("interval");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeSpan>("GameDuration")
+                        .HasColumnType("interval");
+
+                    b.Property<byte>("GameLevel")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("MapCreationPolicy")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumCharacterLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumPlayerCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumSpecialCharacterLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinimumCharacterLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinimumSpecialCharacterLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("RequiresMasterClass")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("SaveRankingStatistics")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("TicketItemId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("TicketItemLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EntranceId");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("TicketItemId");
+
+                    b.ToTable("MiniGameDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameRankingEntry", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CharacterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("GameInstanceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MiniGameId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Rank")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Score")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("MiniGameId");
+
+                    b.ToTable("MiniGameRankingEntry", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameReward", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemRewardId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MiniGameDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("Rank")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("RequiredKillId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("RequiredSuccess")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RewardAmount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RewardType")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemRewardId");
+
+                    b.HasIndex("MiniGameDefinitionId");
+
+                    b.HasIndex("RequiredKillId");
+
+                    b.ToTable("MiniGameReward", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameSpawnWave", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("interval");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("MiniGameDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("interval");
+
+                    b.Property<byte>("WaveNumber")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MiniGameDefinitionId");
+
+                    b.ToTable("MiniGameSpawnWave", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameTerrainChange", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("EndX")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("EndY")
+                        .HasColumnType("smallint");
+
+                    b.Property<bool>("IsClientUpdateRequired")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("MiniGameChangeEventId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("SetTerrainAttribute")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("StartX")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("StartY")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("TerrainAttribute")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MiniGameChangeEventId");
+
+                    b.ToTable("MiniGameTerrainChange", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterAttribute", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AttributeDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MonsterDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<float>("Value")
+                        .HasColumnType("real");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AttributeDefinitionId");
+
+                    b.HasIndex("MonsterDefinitionId");
+
+                    b.ToTable("MonsterAttribute", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeSpan>("AttackDelay")
+                        .HasColumnType("interval");
+
+                    b.Property<byte>("AttackRange")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("AttackSkillId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("Attribute")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("Designation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("IntelligenceTypeName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("MerchantStoreId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeSpan>("MoveDelay")
+                        .HasColumnType("interval");
+
+                    b.Property<byte>("MoveRange")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("NpcWindow")
+                        .HasColumnType("integer");
+
+                    b.Property<short>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("NumberOfMaximumItemDrops")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ObjectKind")
+                        .HasColumnType("integer");
+
+                    b.Property<TimeSpan>("RespawnDelay")
+                        .HasColumnType("interval");
+
+                    b.Property<short>("ViewRange")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AttackSkillId");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("MerchantStoreId")
+                        .IsUnique();
+
+                    b.ToTable("MonsterDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinitionDropItemGroup", b =>
+                {
+                    b.Property<Guid>("MonsterDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("DropItemGroupId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("MonsterDefinitionId", "DropItemGroupId");
+
+                    b.HasIndex("DropItemGroupId");
+
+                    b.ToTable("MonsterDefinitionDropItemGroup", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterSpawnArea", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Direction")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("GameMapId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("MaximumHealthOverride")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("MonsterDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<short>("Quantity")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("SpawnTrigger")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("WaveNumber")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("X1")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("X2")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Y1")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Y2")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameMapId");
+
+                    b.HasIndex("MonsterDefinitionId");
+
+                    b.ToTable("MonsterSpawnArea", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.PlugInConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CustomConfiguration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CustomPlugInSource")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExternalAssemblyName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("TypeId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.ToTable("PlugInConfiguration", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("BoostId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameMapDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MagicEffectDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MagicEffectDefinitionId1")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TargetAttributeId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BoostId")
+                        .IsUnique();
+
+                    b.HasIndex("GameMapDefinitionId");
+
+                    b.HasIndex("MagicEffectDefinitionId");
+
+                    b.HasIndex("MagicEffectDefinitionId1");
+
+                    b.HasIndex("TargetAttributeId");
+
+                    b.ToTable("PowerUpDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinitionValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AggregateType")
+                        .HasColumnType("integer");
+
+                    b.Property<float?>("MaximumValue")
+                        .HasColumnType("real");
+
+                    b.Property<float>("Value")
+                        .HasColumnType("real");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PowerUpDefinitionValue", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<short>("Group")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("MaximumCharacterLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinimumCharacterLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("MonsterDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<short>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("QualifiedCharacterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("QuestGiverId")
+                        .HasColumnType("uuid");
+
+                    b.Property<short>("RefuseNumber")
+                        .HasColumnType("smallint");
+
+                    b.Property<bool>("Repeatable")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("RequiredStartMoney")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("RequiresClientAction")
+                        .HasColumnType("boolean");
+
+                    b.Property<short>("StartingNumber")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MonsterDefinitionId");
+
+                    b.HasIndex("QualifiedCharacterId");
+
+                    b.HasIndex("QuestGiverId");
+
+                    b.ToTable("QuestDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestItemRequirement", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DropItemGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MinimumNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("QuestDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DropItemGroupId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuestDefinitionId");
+
+                    b.ToTable("QuestItemRequirement", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestMonsterKillRequirement", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MinimumNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("MonsterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("QuestDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MonsterId");
+
+                    b.HasIndex("QuestDefinitionId");
+
+                    b.ToTable("QuestMonsterKillRequirement", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestMonsterKillRequirementState", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CharacterQuestStateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("KillCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("RequirementId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterQuestStateId");
+
+                    b.HasIndex("RequirementId");
+
+                    b.ToTable("QuestMonsterKillRequirementState", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestReward", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AttributeRewardId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ItemRewardId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("QuestDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("RewardType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SkillRewardId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AttributeRewardId");
+
+                    b.HasIndex("ItemRewardId")
+                        .IsUnique();
+
+                    b.HasIndex("QuestDefinitionId");
+
+                    b.HasIndex("SkillRewardId");
+
+                    b.ToTable("QuestReward", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Rectangle", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("X1")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("X2")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Y1")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Y2")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Rectangle", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SimpleCraftingSettings", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<byte>("MaximumSuccessPercent")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("Money")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MoneyPerFinalSuccessPercentage")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("MultipleAllowed")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("NpcPriceDivisor")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("ResultItemExcellentOptionChance")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("ResultItemLuckOptionChance")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("ResultItemMaxExcOptionCount")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("ResultItemSelect")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("ResultItemSkillChance")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("SuccessPercent")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("SuccessPercentageAdditionForAncientItem")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SuccessPercentageAdditionForExcellentItem")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SuccessPercentageAdditionForGuardianItem")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SuccessPercentageAdditionForLuck")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SuccessPercentageAdditionForSocketItem")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SimpleCraftingSettings", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AreaSkillSettingsId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttackDamage")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("DamageType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ElementalModifierTargetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<short>("ImplicitTargetRange")
+                        .HasColumnType("smallint");
+
+                    b.Property<Guid?>("MagicEffectDefId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MasterDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("MovesTarget")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("MovesToTarget")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<short>("Number")
+                        .HasColumnType("smallint");
+
+                    b.Property<short>("NumberOfHitsPerAttack")
+                        .HasColumnType("smallint");
+
+                    b.Property<short>("Range")
+                        .HasColumnType("smallint");
+
+                    b.Property<int>("SkillType")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Target")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TargetRestriction")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AreaSkillSettingsId")
+                        .IsUnique();
+
+                    b.HasIndex("ElementalModifierTargetId");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("MagicEffectDefId");
+
+                    b.HasIndex("MasterDefinitionId")
+                        .IsUnique();
+
+                    b.ToTable("Skill", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillCharacterClass", b =>
+                {
+                    b.Property<Guid>("SkillId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CharacterClassId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("SkillId", "CharacterClassId");
+
+                    b.HasIndex("CharacterClassId");
+
+                    b.ToTable("SkillCharacterClass", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillComboDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeSpan>("MaximumCompletionTime")
+                        .HasColumnType("interval");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SkillComboDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillComboStep", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsFinalStep")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SkillComboDefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("SkillId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SkillComboDefinitionId");
+
+                    b.HasIndex("SkillId");
+
+                    b.ToTable("SkillComboStep", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillEntry", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CharacterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SkillId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("SkillId");
+
+                    b.ToTable("SkillEntry", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.StatAttribute", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CharacterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DefinitionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<float>("Value")
+                        .HasColumnType("real");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DefinitionId");
+
+                    b.ToTable("StatAttribute", "data");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.StatAttributeDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AttributeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<float>("BaseValue")
+                        .HasColumnType("real");
+
+                    b.Property<Guid?>("CharacterClassId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IncreasableByPlayer")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AttributeId");
+
+                    b.HasIndex("CharacterClassId");
+
+                    b.ToTable("StatAttributeDefinition", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SystemConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("AutoStart")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AutoUpdateSchema")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("IpResolver")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("IpResolverParameter")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("ReadConsoleInput")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SystemConfiguration", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.WarpInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Costs")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LevelRequirement")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GameConfigurationId");
+
+                    b.HasIndex("GateId");
+
+                    b.ToTable("WarpInfo", "config");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Account", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemStorage", "RawVault")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.Account", "VaultId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawVault");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AccountCharacterClass", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Account", "Account")
+                        .WithMany("JoinedUnlockedCharacterClasses")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "CharacterClass")
+                        .WithMany()
+                        .HasForeignKey("CharacterClassId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("CharacterClass");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AppearanceData", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "RawCharacterClass")
+                        .WithMany()
+                        .HasForeignKey("CharacterClassId");
+
+                    b.Navigation("RawCharacterClass");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawAttributes")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeRelationship", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", null)
+                        .WithMany("RawAttributeCombinations")
+                        .HasForeignKey("CharacterClassId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawGlobalAttributeCombinations")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawInputAttribute")
+                        .WithMany()
+                        .HasForeignKey("InputAttributeId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawOperandAttribute")
+                        .WithMany()
+                        .HasForeignKey("OperandAttributeId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinitionValue", null)
+                        .WithMany("RawRelatedValues")
+                        .HasForeignKey("PowerUpDefinitionValueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", null)
+                        .WithMany("RawAttributeRelationships")
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawTargetAttribute")
+                        .WithMany()
+                        .HasForeignKey("TargetAttributeId");
+
+                    b.Navigation("RawInputAttribute");
+
+                    b.Navigation("RawOperandAttribute");
+
+                    b.Navigation("RawTargetAttribute");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeRequirement", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawAttribute")
+                        .WithMany()
+                        .HasForeignKey("AttributeId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", null)
+                        .WithMany("RawMapRequirements")
+                        .HasForeignKey("GameMapDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", null)
+                        .WithMany("RawRequirements")
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", null)
+                        .WithMany("RawConsumeRequirements")
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", null)
+                        .WithMany("RawRequirements")
+                        .HasForeignKey("SkillId1")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawAttribute");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.BattleZoneDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Rectangle", "RawGround")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.BattleZoneDefinition", "GroundId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Rectangle", "RawLeftGoal")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.BattleZoneDefinition", "LeftGoalId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Rectangle", "RawRightGoal")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.BattleZoneDefinition", "RightGoalId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawGround");
+
+                    b.Navigation("RawLeftGoal");
+
+                    b.Navigation("RawRightGoal");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Account", null)
+                        .WithMany("RawCharacters")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "RawCharacterClass")
+                        .WithMany()
+                        .HasForeignKey("CharacterClassId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", "RawCurrentMap")
+                        .WithMany()
+                        .HasForeignKey("CurrentMapId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemStorage", "RawInventory")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", "InventoryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawCharacterClass");
+
+                    b.Navigation("RawCurrentMap");
+
+                    b.Navigation("RawInventory");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillComboDefinition", "RawComboDefinition")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "ComboDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawCharacterClasses")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", "RawHomeMap")
+                        .WithMany()
+                        .HasForeignKey("HomeMapId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "RawNextGenerationClass")
+                        .WithMany()
+                        .HasForeignKey("NextGenerationClassId");
+
+                    b.Navigation("RawComboDefinition");
+
+                    b.Navigation("RawHomeMap");
+
+                    b.Navigation("RawNextGenerationClass");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterDropItemGroup", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", "Character")
+                        .WithMany("JoinedDropItemGroups")
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", "DropItemGroup")
+                        .WithMany()
+                        .HasForeignKey("DropItemGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("DropItemGroup");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterQuestState", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestDefinition", "RawActiveQuest")
+                        .WithMany()
+                        .HasForeignKey("ActiveQuestId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", null)
+                        .WithMany("RawQuestStates")
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestDefinition", "RawLastFinishedQuest")
+                        .WithMany()
+                        .HasForeignKey("LastFinishedQuestId");
+
+                    b.Navigation("RawActiveQuest");
+
+                    b.Navigation("RawLastFinishedQuest");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ChatServerEndpoint", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ChatServerDefinition", null)
+                        .WithMany("RawEndpoints")
+                        .HasForeignKey("ChatServerDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameClientDefinition", "RawClient")
+                        .WithMany()
+                        .HasForeignKey("ClientId");
+
+                    b.Navigation("RawClient");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CombinationBonusRequirement", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionCombinationBonus", null)
+                        .WithMany("RawRequirements")
+                        .HasForeignKey("ItemOptionCombinationBonusId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionType", "RawOptionType")
+                        .WithMany()
+                        .HasForeignKey("OptionTypeId");
+
+                    b.Navigation("RawOptionType");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ConnectServerDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameClientDefinition", "RawClient")
+                        .WithMany()
+                        .HasForeignKey("ClientId");
+
+                    b.Navigation("RawClient");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ConstValueAttribute", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "CharacterClass")
+                        .WithMany("RawBaseAttributeValues")
+                        .HasForeignKey("CharacterClassId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawDefinition")
+                        .WithMany()
+                        .HasForeignKey("DefinitionId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", "GameConfiguration")
+                        .WithMany("RawGlobalBaseAttributeValues")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("CharacterClass");
+
+                    b.Navigation("GameConfiguration");
+
+                    b.Navigation("RawDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawDropItemGroups")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "RawMonster")
+                        .WithMany()
+                        .HasForeignKey("MonsterId");
+
+                    b.Navigation("RawMonster");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroupItemDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", "DropItemGroup")
+                        .WithMany("JoinedPossibleItems")
+                        .HasForeignKey("DropItemGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "ItemDefinition")
+                        .WithMany()
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DropItemGroup");
+
+                    b.Navigation("ItemDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DuelArea", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.DuelConfiguration", null)
+                        .WithMany("RawDuelAreas")
+                        .HasForeignKey("DuelConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", "RawFirstPlayerGate")
+                        .WithMany()
+                        .HasForeignKey("FirstPlayerGateId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", "RawSecondPlayerGate")
+                        .WithMany()
+                        .HasForeignKey("SecondPlayerGateId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", "RawSpectatorsGate")
+                        .WithMany()
+                        .HasForeignKey("SpectatorsGateId");
+
+                    b.Navigation("RawFirstPlayerGate");
+
+                    b.Navigation("RawSecondPlayerGate");
+
+                    b.Navigation("RawSpectatorsGate");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DuelConfiguration", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", "RawExit")
+                        .WithMany()
+                        .HasForeignKey("ExitId");
+
+                    b.Navigation("RawExit");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.EnterGate", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", null)
+                        .WithMany("RawEnterGates")
+                        .HasForeignKey("GameMapDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", "RawTargetGate")
+                        .WithMany()
+                        .HasForeignKey("TargetGateId");
+
+                    b.Navigation("RawTargetGate");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", "RawMap")
+                        .WithMany("RawExitGates")
+                        .HasForeignKey("MapId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawMap");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.DuelConfiguration", "RawDuelConfiguration")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", "DuelConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawDuelConfiguration");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.BattleZoneDefinition", "RawBattleZone")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", "BattleZoneId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawMaps")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", "RawSafezoneMap")
+                        .WithMany()
+                        .HasForeignKey("SafezoneMapId");
+
+                    b.Navigation("RawBattleZone");
+
+                    b.Navigation("RawSafezoneMap");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinitionDropItemGroup", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", "DropItemGroup")
+                        .WithMany()
+                        .HasForeignKey("DropItemGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", "GameMapDefinition")
+                        .WithMany("JoinedDropItemGroups")
+                        .HasForeignKey("GameMapDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DropItemGroup");
+
+                    b.Navigation("GameMapDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerConfigurationGameMapDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", "GameMapDefinition")
+                        .WithMany()
+                        .HasForeignKey("GameMapDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerConfiguration", "GameServerConfiguration")
+                        .WithMany("JoinedMaps")
+                        .HasForeignKey("GameServerConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GameMapDefinition");
+
+                    b.Navigation("GameServerConfiguration");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", "RawGameConfiguration")
+                        .WithMany()
+                        .HasForeignKey("GameConfigurationId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerConfiguration", "RawServerConfiguration")
+                        .WithMany()
+                        .HasForeignKey("ServerConfigurationId");
+
+                    b.Navigation("RawGameConfiguration");
+
+                    b.Navigation("RawServerConfiguration");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerEndpoint", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameClientDefinition", "RawClient")
+                        .WithMany()
+                        .HasForeignKey("ClientId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerDefinition", null)
+                        .WithMany("RawEndpoints")
+                        .HasForeignKey("GameServerDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawClient");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Guild", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Guild", "RawAllianceGuild")
+                        .WithMany()
+                        .HasForeignKey("AllianceGuildId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Guild", "RawHostility")
+                        .WithMany()
+                        .HasForeignKey("HostilityId");
+
+                    b.Navigation("RawAllianceGuild");
+
+                    b.Navigation("RawHostility");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GuildMember", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Guild", null)
+                        .WithMany("RawMembers")
+                        .HasForeignKey("GuildId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", "Character")
+                        .WithMany()
+                        .HasForeignKey("Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.IncreasableItemOption", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionDefinition", null)
+                        .WithMany("RawPossibleOptions")
+                        .HasForeignKey("ItemOptionDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionType", "RawOptionType")
+                        .WithMany()
+                        .HasForeignKey("OptionTypeId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinition", "RawPowerUpDefinition")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.IncreasableItemOption", "PowerUpDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawOptionType");
+
+                    b.Navigation("RawPowerUpDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Item", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "RawDefinition")
+                        .WithMany()
+                        .HasForeignKey("DefinitionId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemStorage", "RawItemStorage")
+                        .WithMany("RawItems")
+                        .HasForeignKey("ItemStorageId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawDefinition");
+
+                    b.Navigation("RawItemStorage");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemAppearance", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AppearanceData", null)
+                        .WithMany("RawEquippedItems")
+                        .HasForeignKey("AppearanceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "RawDefinition")
+                        .WithMany()
+                        .HasForeignKey("DefinitionId");
+
+                    b.Navigation("RawDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemAppearanceItemOptionType", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemAppearance", "ItemAppearance")
+                        .WithMany("JoinedVisibleOptions")
+                        .HasForeignKey("ItemAppearanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionType", "ItemOptionType")
+                        .WithMany()
+                        .HasForeignKey("ItemOptionTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ItemAppearance");
+
+                    b.Navigation("ItemOptionType");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemBasePowerUpDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemLevelBonusTable", "RawBonusPerLevelTable")
+                        .WithMany()
+                        .HasForeignKey("BonusPerLevelTableId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", null)
+                        .WithMany("RawBasePowerUpAttributes")
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawTargetAttribute")
+                        .WithMany()
+                        .HasForeignKey("TargetAttributeId");
+
+                    b.Navigation("RawBonusPerLevelTable");
+
+                    b.Navigation("RawTargetAttribute");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCrafting", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", null)
+                        .WithMany("RawItemCraftings")
+                        .HasForeignKey("MonsterDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.SimpleCraftingSettings", "RawSimpleCraftingSettings")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCrafting", "SimpleCraftingSettingsId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawSimpleCraftingSettings");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItem", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.SimpleCraftingSettings", null)
+                        .WithMany("RawRequiredItems")
+                        .HasForeignKey("SimpleCraftingSettingsId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItemItemDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItem", "ItemCraftingRequiredItem")
+                        .WithMany("JoinedPossibleItems")
+                        .HasForeignKey("ItemCraftingRequiredItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "ItemDefinition")
+                        .WithMany()
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ItemCraftingRequiredItem");
+
+                    b.Navigation("ItemDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItemItemOptionType", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItem", "ItemCraftingRequiredItem")
+                        .WithMany("JoinedRequiredItemOptions")
+                        .HasForeignKey("ItemCraftingRequiredItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionType", "ItemOptionType")
+                        .WithMany()
+                        .HasForeignKey("ItemOptionTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ItemCraftingRequiredItem");
+
+                    b.Navigation("ItemOptionType");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingResultItem", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "RawItemDefinition")
+                        .WithMany()
+                        .HasForeignKey("ItemDefinitionId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.SimpleCraftingSettings", null)
+                        .WithMany("RawResultItems")
+                        .HasForeignKey("SimpleCraftingSettingsId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawItemDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", "RawConsumeEffect")
+                        .WithMany()
+                        .HasForeignKey("ConsumeEffectId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawItems")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemSlotType", "RawItemSlot")
+                        .WithMany()
+                        .HasForeignKey("ItemSlotId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "RawSkill")
+                        .WithMany()
+                        .HasForeignKey("SkillId");
+
+                    b.Navigation("RawConsumeEffect");
+
+                    b.Navigation("RawItemSlot");
+
+                    b.Navigation("RawSkill");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinitionCharacterClass", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "CharacterClass")
+                        .WithMany()
+                        .HasForeignKey("CharacterClassId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "ItemDefinition")
+                        .WithMany("JoinedQualifiedCharacters")
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CharacterClass");
+
+                    b.Navigation("ItemDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinitionItemOptionDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "ItemDefinition")
+                        .WithMany("JoinedPossibleItemOptions")
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionDefinition", "ItemOptionDefinition")
+                        .WithMany()
+                        .HasForeignKey("ItemOptionDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ItemDefinition");
+
+                    b.Navigation("ItemOptionDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinitionItemSetGroup", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "ItemDefinition")
+                        .WithMany("JoinedPossibleItemSetGroups")
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemSetGroup", "ItemSetGroup")
+                        .WithMany()
+                        .HasForeignKey("ItemSetGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ItemDefinition");
+
+                    b.Navigation("ItemSetGroup");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDropItemGroup", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", null)
+                        .WithMany("RawDropItems")
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "RawMonster")
+                        .WithMany()
+                        .HasForeignKey("MonsterId");
+
+                    b.Navigation("RawMonster");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDropItemGroupItemDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "ItemDefinition")
+                        .WithMany()
+                        .HasForeignKey("ItemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDropItemGroup", "ItemDropItemGroup")
+                        .WithMany("JoinedPossibleItems")
+                        .HasForeignKey("ItemDropItemGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ItemDefinition");
+
+                    b.Navigation("ItemDropItemGroup");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemItemOfItemSet", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Item", "Item")
+                        .WithMany("JoinedItemSetGroups")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOfItemSet", "ItemOfItemSet")
+                        .WithMany()
+                        .HasForeignKey("ItemOfItemSetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("ItemOfItemSet");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemLevelBonusTable", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawItemLevelBonusTables")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOfItemSet", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.IncreasableItemOption", "RawBonusOption")
+                        .WithMany()
+                        .HasForeignKey("BonusOptionId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "RawItemDefinition")
+                        .WithMany()
+                        .HasForeignKey("ItemDefinitionId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemSetGroup", "RawItemSetGroup")
+                        .WithMany("RawItems")
+                        .HasForeignKey("ItemSetGroupId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawBonusOption");
+
+                    b.Navigation("RawItemDefinition");
+
+                    b.Navigation("RawItemSetGroup");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOption", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionType", "RawOptionType")
+                        .WithMany()
+                        .HasForeignKey("OptionTypeId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinition", "RawPowerUpDefinition")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOption", "PowerUpDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawOptionType");
+
+                    b.Navigation("RawPowerUpDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionCombinationBonus", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinition", "RawBonus")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionCombinationBonus", "BonusId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawItemOptionCombinationBonuses")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawBonus");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawItemOptions")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionLink", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Item", null)
+                        .WithMany("RawItemOptions")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.IncreasableItemOption", "RawItemOption")
+                        .WithMany()
+                        .HasForeignKey("ItemOptionId");
+
+                    b.Navigation("RawItemOption");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionOfLevel", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.IncreasableItemOption", null)
+                        .WithMany("RawLevelDependentOptions")
+                        .HasForeignKey("IncreasableItemOptionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinition", "RawPowerUpDefinition")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionOfLevel", "PowerUpDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawPowerUpDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionType", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawItemOptionTypes")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemSetGroup", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawItemSetGroups")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionDefinition", "RawOptions")
+                        .WithMany()
+                        .HasForeignKey("OptionsId");
+
+                    b.Navigation("RawOptions");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemSlotType", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawItemSlotTypes")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.JewelMix", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawJewelMixes")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "RawMixedJewel")
+                        .WithMany()
+                        .HasForeignKey("MixedJewelId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "RawSingleJewel")
+                        .WithMany()
+                        .HasForeignKey("SingleJewelId");
+
+                    b.Navigation("RawMixedJewel");
+
+                    b.Navigation("RawSingleJewel");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.LetterBody", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.LetterHeader", "RawHeader")
+                        .WithMany()
+                        .HasForeignKey("HeaderId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AppearanceData", "RawSenderAppearance")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.LetterBody", "SenderAppearanceId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawHeader");
+
+                    b.Navigation("RawSenderAppearance");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.LetterHeader", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", "Receiver")
+                        .WithMany("RawLetters")
+                        .HasForeignKey("ReceiverId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Receiver");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.LevelBonus", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemLevelBonusTable", null)
+                        .WithMany("RawBonusPerLevel")
+                        .HasForeignKey("ItemLevelBonusTableId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinitionValue", "RawChance")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", "ChanceId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinitionValue", "RawChancePvp")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", "ChancePvpId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinitionValue", "RawDuration")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", "DurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinitionValue", "RawDurationPvp")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", "DurationPvpId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawMagicEffects")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawChance");
+
+                    b.Navigation("RawChancePvp");
+
+                    b.Navigation("RawDuration");
+
+                    b.Navigation("RawDurationPvp");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "RawReplacedSkill")
+                        .WithMany()
+                        .HasForeignKey("ReplacedSkillId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillRoot", "RawRoot")
+                        .WithMany()
+                        .HasForeignKey("RootId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawTargetAttribute")
+                        .WithMany()
+                        .HasForeignKey("TargetAttributeId");
+
+                    b.Navigation("RawReplacedSkill");
+
+                    b.Navigation("RawRoot");
+
+                    b.Navigation("RawTargetAttribute");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillDefinitionSkill", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillDefinition", "MasterSkillDefinition")
+                        .WithMany("JoinedRequiredMasterSkills")
+                        .HasForeignKey("MasterSkillDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "Skill")
+                        .WithMany()
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterSkillDefinition");
+
+                    b.Navigation("Skill");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillRoot", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawMasterSkillRoots")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameChangeEvent", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameDefinition", null)
+                        .WithMany("RawChangeEvents")
+                        .HasForeignKey("MiniGameDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterSpawnArea", "RawSpawnArea")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameChangeEvent", "SpawnAreaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "RawTargetDefinition")
+                        .WithMany()
+                        .HasForeignKey("TargetDefinitionId");
+
+                    b.Navigation("RawSpawnArea");
+
+                    b.Navigation("RawTargetDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", "RawEntrance")
+                        .WithMany()
+                        .HasForeignKey("EntranceId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawMiniGameDefinitions")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "RawTicketItem")
+                        .WithMany()
+                        .HasForeignKey("TicketItemId");
+
+                    b.Navigation("RawEntrance");
+
+                    b.Navigation("RawTicketItem");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameRankingEntry", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", "RawCharacter")
+                        .WithMany()
+                        .HasForeignKey("CharacterId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameDefinition", "RawMiniGame")
+                        .WithMany()
+                        .HasForeignKey("MiniGameId");
+
+                    b.Navigation("RawCharacter");
+
+                    b.Navigation("RawMiniGame");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameReward", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", "RawItemReward")
+                        .WithMany()
+                        .HasForeignKey("ItemRewardId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameDefinition", null)
+                        .WithMany("RawRewards")
+                        .HasForeignKey("MiniGameDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "RawRequiredKill")
+                        .WithMany()
+                        .HasForeignKey("RequiredKillId");
+
+                    b.Navigation("RawItemReward");
+
+                    b.Navigation("RawRequiredKill");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameSpawnWave", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameDefinition", null)
+                        .WithMany("RawSpawnWaves")
+                        .HasForeignKey("MiniGameDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameTerrainChange", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameChangeEvent", null)
+                        .WithMany("RawTerrainChanges")
+                        .HasForeignKey("MiniGameChangeEventId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterAttribute", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawAttributeDefinition")
+                        .WithMany()
+                        .HasForeignKey("AttributeDefinitionId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", null)
+                        .WithMany("RawAttributes")
+                        .HasForeignKey("MonsterDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawAttributeDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "RawAttackSkill")
+                        .WithMany()
+                        .HasForeignKey("AttackSkillId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawMonsters")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemStorage", "RawMerchantStore")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "MerchantStoreId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawAttackSkill");
+
+                    b.Navigation("RawMerchantStore");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinitionDropItemGroup", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", "DropItemGroup")
+                        .WithMany()
+                        .HasForeignKey("DropItemGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "MonsterDefinition")
+                        .WithMany("JoinedDropItemGroups")
+                        .HasForeignKey("MonsterDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DropItemGroup");
+
+                    b.Navigation("MonsterDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterSpawnArea", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", "RawGameMap")
+                        .WithMany("RawMonsterSpawns")
+                        .HasForeignKey("GameMapId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "RawMonsterDefinition")
+                        .WithMany()
+                        .HasForeignKey("MonsterDefinitionId");
+
+                    b.Navigation("RawGameMap");
+
+                    b.Navigation("RawMonsterDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.PlugInConfiguration", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawPlugInConfigurations")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinitionValue", "RawBoost")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinition", "BoostId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", null)
+                        .WithMany("RawCharacterPowerUpDefinitions")
+                        .HasForeignKey("GameMapDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", null)
+                        .WithMany("RawPowerUpDefinitions")
+                        .HasForeignKey("MagicEffectDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", null)
+                        .WithMany("RawPowerUpDefinitionsPvp")
+                        .HasForeignKey("MagicEffectDefinitionId1")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_PowerUpDefinition_MagicEffectDefinition_MagicEffectDefinit~1");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawTargetAttribute")
+                        .WithMany()
+                        .HasForeignKey("TargetAttributeId");
+
+                    b.Navigation("RawBoost");
+
+                    b.Navigation("RawTargetAttribute");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", null)
+                        .WithMany("RawQuests")
+                        .HasForeignKey("MonsterDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "RawQualifiedCharacter")
+                        .WithMany()
+                        .HasForeignKey("QualifiedCharacterId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "RawQuestGiver")
+                        .WithMany()
+                        .HasForeignKey("QuestGiverId");
+
+                    b.Navigation("RawQualifiedCharacter");
+
+                    b.Navigation("RawQuestGiver");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestItemRequirement", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", "RawDropItemGroup")
+                        .WithMany()
+                        .HasForeignKey("DropItemGroupId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", "RawItem")
+                        .WithMany()
+                        .HasForeignKey("ItemId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestDefinition", null)
+                        .WithMany("RawRequiredItems")
+                        .HasForeignKey("QuestDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawDropItemGroup");
+
+                    b.Navigation("RawItem");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestMonsterKillRequirement", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", "RawMonster")
+                        .WithMany()
+                        .HasForeignKey("MonsterId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestDefinition", null)
+                        .WithMany("RawRequiredMonsterKills")
+                        .HasForeignKey("QuestDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawMonster");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestMonsterKillRequirementState", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterQuestState", null)
+                        .WithMany("RawRequirementStates")
+                        .HasForeignKey("CharacterQuestStateId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestMonsterKillRequirement", "RawRequirement")
+                        .WithMany()
+                        .HasForeignKey("RequirementId");
+
+                    b.Navigation("RawRequirement");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestReward", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawAttributeReward")
+                        .WithMany()
+                        .HasForeignKey("AttributeRewardId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Item", "RawItemReward")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestReward", "ItemRewardId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestDefinition", null)
+                        .WithMany("RawRewards")
+                        .HasForeignKey("QuestDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "RawSkillReward")
+                        .WithMany()
+                        .HasForeignKey("SkillRewardId");
+
+                    b.Navigation("RawAttributeReward");
+
+                    b.Navigation("RawItemReward");
+
+                    b.Navigation("RawSkillReward");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AreaSkillSettings", "RawAreaSkillSettings")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "AreaSkillSettingsId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawElementalModifierTarget")
+                        .WithMany()
+                        .HasForeignKey("ElementalModifierTargetId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawSkills")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", "RawMagicEffectDef")
+                        .WithMany()
+                        .HasForeignKey("MagicEffectDefId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillDefinition", "RawMasterDefinition")
+                        .WithOne()
+                        .HasForeignKey("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "MasterDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawAreaSkillSettings");
+
+                    b.Navigation("RawElementalModifierTarget");
+
+                    b.Navigation("RawMagicEffectDef");
+
+                    b.Navigation("RawMasterDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillCharacterClass", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "CharacterClass")
+                        .WithMany()
+                        .HasForeignKey("CharacterClassId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "Skill")
+                        .WithMany("JoinedQualifiedCharacters")
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CharacterClass");
+
+                    b.Navigation("Skill");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillComboStep", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillComboDefinition", null)
+                        .WithMany("RawSteps")
+                        .HasForeignKey("SkillComboDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "RawSkill")
+                        .WithMany()
+                        .HasForeignKey("SkillId");
+
+                    b.Navigation("RawSkill");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillEntry", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", null)
+                        .WithMany("RawLearnedSkills")
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", "RawSkill")
+                        .WithMany()
+                        .HasForeignKey("SkillId");
+
+                    b.Navigation("RawSkill");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.StatAttribute", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Account", null)
+                        .WithMany("RawAttributes")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", null)
+                        .WithMany("RawAttributes")
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawDefinition")
+                        .WithMany()
+                        .HasForeignKey("DefinitionId");
+
+                    b.Navigation("RawDefinition");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.StatAttributeDefinition", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawAttribute")
+                        .WithMany()
+                        .HasForeignKey("AttributeId");
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", null)
+                        .WithMany("RawStatAttributes")
+                        .HasForeignKey("CharacterClassId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("RawAttribute");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.WarpInfo", b =>
+                {
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawWarpList")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.ExitGate", "RawGate")
+                        .WithMany()
+                        .HasForeignKey("GateId");
+
+                    b.Navigation("RawGate");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Account", b =>
+                {
+                    b.Navigation("JoinedUnlockedCharacterClasses");
+
+                    b.Navigation("RawAttributes");
+
+                    b.Navigation("RawCharacters");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.AppearanceData", b =>
+                {
+                    b.Navigation("RawEquippedItems");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Character", b =>
+                {
+                    b.Navigation("JoinedDropItemGroups");
+
+                    b.Navigation("RawAttributes");
+
+                    b.Navigation("RawLearnedSkills");
+
+                    b.Navigation("RawLetters");
+
+                    b.Navigation("RawQuestStates");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", b =>
+                {
+                    b.Navigation("RawAttributeCombinations");
+
+                    b.Navigation("RawBaseAttributeValues");
+
+                    b.Navigation("RawStatAttributes");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterQuestState", b =>
+                {
+                    b.Navigation("RawRequirementStates");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ChatServerDefinition", b =>
+                {
+                    b.Navigation("RawEndpoints");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DropItemGroup", b =>
+                {
+                    b.Navigation("JoinedPossibleItems");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.DuelConfiguration", b =>
+                {
+                    b.Navigation("RawDuelAreas");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", b =>
+                {
+                    b.Navigation("RawAttributes");
+
+                    b.Navigation("RawCharacterClasses");
+
+                    b.Navigation("RawDropItemGroups");
+
+                    b.Navigation("RawGlobalAttributeCombinations");
+
+                    b.Navigation("RawGlobalBaseAttributeValues");
+
+                    b.Navigation("RawItemLevelBonusTables");
+
+                    b.Navigation("RawItemOptionCombinationBonuses");
+
+                    b.Navigation("RawItemOptionTypes");
+
+                    b.Navigation("RawItemOptions");
+
+                    b.Navigation("RawItemSetGroups");
+
+                    b.Navigation("RawItemSlotTypes");
+
+                    b.Navigation("RawItems");
+
+                    b.Navigation("RawJewelMixes");
+
+                    b.Navigation("RawMagicEffects");
+
+                    b.Navigation("RawMaps");
+
+                    b.Navigation("RawMasterSkillRoots");
+
+                    b.Navigation("RawMiniGameDefinitions");
+
+                    b.Navigation("RawMonsters");
+
+                    b.Navigation("RawPlugInConfigurations");
+
+                    b.Navigation("RawSkills");
+
+                    b.Navigation("RawWarpList");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameMapDefinition", b =>
+                {
+                    b.Navigation("JoinedDropItemGroups");
+
+                    b.Navigation("RawCharacterPowerUpDefinitions");
+
+                    b.Navigation("RawEnterGates");
+
+                    b.Navigation("RawExitGates");
+
+                    b.Navigation("RawMapRequirements");
+
+                    b.Navigation("RawMonsterSpawns");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerConfiguration", b =>
+                {
+                    b.Navigation("JoinedMaps");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.GameServerDefinition", b =>
+                {
+                    b.Navigation("RawEndpoints");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Guild", b =>
+                {
+                    b.Navigation("RawMembers");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.IncreasableItemOption", b =>
+                {
+                    b.Navigation("RawLevelDependentOptions");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Item", b =>
+                {
+                    b.Navigation("JoinedItemSetGroups");
+
+                    b.Navigation("RawItemOptions");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemAppearance", b =>
+                {
+                    b.Navigation("JoinedVisibleOptions");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemCraftingRequiredItem", b =>
+                {
+                    b.Navigation("JoinedPossibleItems");
+
+                    b.Navigation("JoinedRequiredItemOptions");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDefinition", b =>
+                {
+                    b.Navigation("JoinedPossibleItemOptions");
+
+                    b.Navigation("JoinedPossibleItemSetGroups");
+
+                    b.Navigation("JoinedQualifiedCharacters");
+
+                    b.Navigation("RawBasePowerUpAttributes");
+
+                    b.Navigation("RawDropItems");
+
+                    b.Navigation("RawRequirements");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemDropItemGroup", b =>
+                {
+                    b.Navigation("JoinedPossibleItems");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemLevelBonusTable", b =>
+                {
+                    b.Navigation("RawBonusPerLevel");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionCombinationBonus", b =>
+                {
+                    b.Navigation("RawRequirements");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemOptionDefinition", b =>
+                {
+                    b.Navigation("RawPossibleOptions");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemSetGroup", b =>
+                {
+                    b.Navigation("RawItems");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.ItemStorage", b =>
+                {
+                    b.Navigation("RawItems");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MagicEffectDefinition", b =>
+                {
+                    b.Navigation("RawPowerUpDefinitions");
+
+                    b.Navigation("RawPowerUpDefinitionsPvp");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MasterSkillDefinition", b =>
+                {
+                    b.Navigation("JoinedRequiredMasterSkills");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameChangeEvent", b =>
+                {
+                    b.Navigation("RawTerrainChanges");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MiniGameDefinition", b =>
+                {
+                    b.Navigation("RawChangeEvents");
+
+                    b.Navigation("RawRewards");
+
+                    b.Navigation("RawSpawnWaves");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.MonsterDefinition", b =>
+                {
+                    b.Navigation("JoinedDropItemGroups");
+
+                    b.Navigation("RawAttributes");
+
+                    b.Navigation("RawItemCraftings");
+
+                    b.Navigation("RawQuests");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.PowerUpDefinitionValue", b =>
+                {
+                    b.Navigation("RawRelatedValues");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.QuestDefinition", b =>
+                {
+                    b.Navigation("RawRequiredItems");
+
+                    b.Navigation("RawRequiredMonsterKills");
+
+                    b.Navigation("RawRewards");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SimpleCraftingSettings", b =>
+                {
+                    b.Navigation("RawRequiredItems");
+
+                    b.Navigation("RawResultItems");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.Skill", b =>
+                {
+                    b.Navigation("JoinedQualifiedCharacters");
+
+                    b.Navigation("RawAttributeRelationships");
+
+                    b.Navigation("RawConsumeRequirements");
+
+                    b.Navigation("RawRequirements");
+                });
+
+            modelBuilder.Entity("MUnique.OpenMU.Persistence.EntityFramework.Model.SkillComboDefinition", b =>
+                {
+                    b.Navigation("RawSteps");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Persistence/EntityFramework/Migrations/20260320211230_AddGlobalAttributes.cs b/src/Persistence/EntityFramework/Migrations/20260320211230_AddGlobalAttributes.cs
new file mode 100644
index 000000000..8a4f1cbf0
--- /dev/null
+++ b/src/Persistence/EntityFramework/Migrations/20260320211230_AddGlobalAttributes.cs
@@ -0,0 +1,115 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MUnique.OpenMU.Persistence.EntityFramework.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddGlobalAttributes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<Guid>(
+                name: "CharacterClassId",
+                schema: "config",
+                table: "ConstValueAttribute",
+                type: "uuid",
+                nullable: true,
+                oldClrType: typeof(Guid),
+                oldType: "uuid");
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "GameConfigurationId",
+                schema: "config",
+                table: "ConstValueAttribute",
+                type: "uuid",
+                nullable: true);
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "GameConfigurationId",
+                schema: "config",
+                table: "AttributeRelationship",
+                type: "uuid",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ConstValueAttribute_GameConfigurationId",
+                schema: "config",
+                table: "ConstValueAttribute",
+                column: "GameConfigurationId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AttributeRelationship_GameConfigurationId",
+                schema: "config",
+                table: "AttributeRelationship",
+                column: "GameConfigurationId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AttributeRelationship_GameConfiguration_GameConfigurationId",
+                schema: "config",
+                table: "AttributeRelationship",
+                column: "GameConfigurationId",
+                principalSchema: "config",
+                principalTable: "GameConfiguration",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ConstValueAttribute_GameConfiguration_GameConfigurationId",
+                schema: "config",
+                table: "ConstValueAttribute",
+                column: "GameConfigurationId",
+                principalSchema: "config",
+                principalTable: "GameConfiguration",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AttributeRelationship_GameConfiguration_GameConfigurationId",
+                schema: "config",
+                table: "AttributeRelationship");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ConstValueAttribute_GameConfiguration_GameConfigurationId",
+                schema: "config",
+                table: "ConstValueAttribute");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ConstValueAttribute_GameConfigurationId",
+                schema: "config",
+                table: "ConstValueAttribute");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AttributeRelationship_GameConfigurationId",
+                schema: "config",
+                table: "AttributeRelationship");
+
+            migrationBuilder.DropColumn(
+                name: "GameConfigurationId",
+                schema: "config",
+                table: "ConstValueAttribute");
+
+            migrationBuilder.DropColumn(
+                name: "GameConfigurationId",
+                schema: "config",
+                table: "AttributeRelationship");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "CharacterClassId",
+                schema: "config",
+                table: "ConstValueAttribute",
+                type: "uuid",
+                nullable: false,
+                defaultValue: new Guid("00000000-0000-0000-0000-000000000000"),
+                oldClrType: typeof(Guid),
+                oldType: "uuid",
+                oldNullable: true);
+        }
+    }
+}
diff --git a/src/Persistence/EntityFramework/Migrations/EntityDataContextModelSnapshot.cs b/src/Persistence/EntityFramework/Migrations/EntityDataContextModelSnapshot.cs
index 429cb96aa..4d755d1b8 100644
--- a/src/Persistence/EntityFramework/Migrations/EntityDataContextModelSnapshot.cs
+++ b/src/Persistence/EntityFramework/Migrations/EntityDataContextModelSnapshot.cs
@@ -215,6 +215,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<Guid?>("CharacterClassId")
                         .HasColumnType("uuid");
 
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
                     b.Property<Guid?>("InputAttributeId")
                         .HasColumnType("uuid");
 
@@ -240,6 +243,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("CharacterClassId");
 
+                    b.HasIndex("GameConfigurationId");
+
                     b.HasIndex("InputAttributeId");
 
                     b.HasIndex("OperandAttributeId");
@@ -735,12 +740,15 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uuid");
 
-                    b.Property<Guid>("CharacterClassId")
+                    b.Property<Guid?>("CharacterClassId")
                         .HasColumnType("uuid");
 
                     b.Property<Guid?>("DefinitionId")
                         .HasColumnType("uuid");
 
+                    b.Property<Guid?>("GameConfigurationId")
+                        .HasColumnType("uuid");
+
                     b.Property<float>("Value")
                         .HasColumnType("real");
 
@@ -750,6 +758,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DefinitionId");
 
+                    b.HasIndex("GameConfigurationId");
+
                     b.ToTable("ConstValueAttribute", "config");
                 });
 
@@ -3472,6 +3482,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasForeignKey("CharacterClassId")
                         .OnDelete(DeleteBehavior.Cascade);
 
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", null)
+                        .WithMany("RawGlobalAttributeCombinations")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
                     b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawInputAttribute")
                         .WithMany()
                         .HasForeignKey("InputAttributeId");
@@ -3691,15 +3706,21 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.CharacterClass", "CharacterClass")
                         .WithMany("RawBaseAttributeValues")
                         .HasForeignKey("CharacterClassId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
+                        .OnDelete(DeleteBehavior.Cascade);
 
                     b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.AttributeDefinition", "RawDefinition")
                         .WithMany()
                         .HasForeignKey("DefinitionId");
 
+                    b.HasOne("MUnique.OpenMU.Persistence.EntityFramework.Model.GameConfiguration", "GameConfiguration")
+                        .WithMany("RawGlobalBaseAttributeValues")
+                        .HasForeignKey("GameConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
                     b.Navigation("CharacterClass");
 
+                    b.Navigation("GameConfiguration");
+
                     b.Navigation("RawDefinition");
                 });
 
@@ -4981,6 +5002,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.Navigation("RawDropItemGroups");
 
+                    b.Navigation("RawGlobalAttributeCombinations");
+
+                    b.Navigation("RawGlobalBaseAttributeValues");
+
                     b.Navigation("RawItemLevelBonusTables");
 
                     b.Navigation("RawItemOptionCombinationBonuses");
diff --git a/src/Persistence/EntityFramework/Model/ExtendedTypeContext.Generated.cs b/src/Persistence/EntityFramework/Model/ExtendedTypeContext.Generated.cs
index 88fc1437c..7d8b738be 100644
--- a/src/Persistence/EntityFramework/Model/ExtendedTypeContext.Generated.cs
+++ b/src/Persistence/EntityFramework/Model/ExtendedTypeContext.Generated.cs
@@ -153,6 +153,8 @@ protected override void OnModelCreating(Microsoft.EntityFrameworkCore.ModelBuild
         modelBuilder.Entity<GameConfiguration>().HasMany(entity => entity.RawAttributes).WithOne().OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<GameConfiguration>().HasMany(entity => entity.RawMagicEffects).WithOne().OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<GameConfiguration>().HasMany(entity => entity.RawMasterSkillRoots).WithOne().OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<GameConfiguration>().HasMany(entity => entity.RawGlobalAttributeCombinations).WithOne().OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<GameConfiguration>().HasMany(entity => entity.RawGlobalBaseAttributeValues).WithOne().OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<GameConfiguration>().HasMany(entity => entity.RawPlugInConfigurations).WithOne().OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<GameConfiguration>().HasMany(entity => entity.RawMiniGameDefinitions).WithOne().OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<GameMapDefinition>().HasMany(entity => entity.RawMonsterSpawns).WithOne().OnDelete(DeleteBehavior.Cascade);
diff --git a/src/Persistence/EntityFramework/Model/ExtendedTypes.Custom.cs b/src/Persistence/EntityFramework/Model/ExtendedTypes.Custom.cs
index 4131dda43..624270cb2 100644
--- a/src/Persistence/EntityFramework/Model/ExtendedTypes.Custom.cs
+++ b/src/Persistence/EntityFramework/Model/ExtendedTypes.Custom.cs
@@ -66,7 +66,7 @@ public ConstValueAttribute()
     /// <value>
     /// The character class identifier.
     /// </value>
-    public Guid CharacterClassId { get; set; }
+    public Guid? CharacterClassId { get; set; }
 
     /// <summary>
     /// Gets or sets the character class.
@@ -76,6 +76,22 @@ public ConstValueAttribute()
     /// </value>
     public CharacterClass? CharacterClass { get; set; }
 
+    /// <summary>
+    /// Gets or sets the game configuration identifier.
+    /// </summary>
+    /// <value>
+    /// The game configuration identifier.
+    /// </value>
+    public Guid? GameConfigurationId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the game configuration.
+    /// </summary>
+    /// <value>
+    /// The game configuration.
+    /// </value>
+    public GameConfiguration? GameConfiguration { get; set; }
+
     /// <inheritdoc />
     public new float Value
     {
diff --git a/src/Persistence/EntityFramework/Model/GameConfiguration.Generated.cs b/src/Persistence/EntityFramework/Model/GameConfiguration.Generated.cs
index 8e8d19239..ec2d58713 100644
--- a/src/Persistence/EntityFramework/Model/GameConfiguration.Generated.cs
+++ b/src/Persistence/EntityFramework/Model/GameConfiguration.Generated.cs
@@ -181,6 +181,24 @@ internal partial class GameConfiguration : MUnique.OpenMU.DataModel.Configuratio
     [NotMapped]
     public override ICollection<MUnique.OpenMU.DataModel.Configuration.MasterSkillRoot> MasterSkillRoots => base.MasterSkillRoots ??= new CollectionAdapter<MUnique.OpenMU.DataModel.Configuration.MasterSkillRoot, MasterSkillRoot>(this.RawMasterSkillRoots);
 
+    /// <summary>
+    /// Gets the raw collection of <see cref="GlobalAttributeCombinations" />.
+    /// </summary>
+    public ICollection<AttributeRelationship> RawGlobalAttributeCombinations { get; } = new EntityFramework.List<AttributeRelationship>();
+    
+    /// <inheritdoc/>
+    [NotMapped]
+    public override ICollection<MUnique.OpenMU.AttributeSystem.AttributeRelationship> GlobalAttributeCombinations => base.GlobalAttributeCombinations ??= new CollectionAdapter<MUnique.OpenMU.AttributeSystem.AttributeRelationship, AttributeRelationship>(this.RawGlobalAttributeCombinations);
+
+    /// <summary>
+    /// Gets the raw collection of <see cref="GlobalBaseAttributeValues" />.
+    /// </summary>
+    public ICollection<ConstValueAttribute> RawGlobalBaseAttributeValues { get; } = new EntityFramework.List<ConstValueAttribute>();
+    
+    /// <inheritdoc/>
+    [NotMapped]
+    public override ICollection<MUnique.OpenMU.AttributeSystem.ConstValueAttribute> GlobalBaseAttributeValues => base.GlobalBaseAttributeValues ??= new CollectionAdapter<MUnique.OpenMU.AttributeSystem.ConstValueAttribute, ConstValueAttribute>(this.RawGlobalBaseAttributeValues);
+
     /// <summary>
     /// Gets the raw collection of <see cref="PlugInConfigurations" />.
     /// </summary>
diff --git a/src/Persistence/Initialization/CharacterClasses/CharacterClassInitialization.cs b/src/Persistence/Initialization/CharacterClasses/CharacterClassInitialization.cs
index 1b944968b..59c0f3c99 100644
--- a/src/Persistence/Initialization/CharacterClasses/CharacterClassInitialization.cs
+++ b/src/Persistence/Initialization/CharacterClasses/CharacterClassInitialization.cs
@@ -159,7 +159,6 @@ private void AddCommonBaseAttributeValues(ICollection<ConstValueAttribute> baseA
         baseAttributeValues.Add(this.CreateConstValueAttribute(1.0f / 27.5f, Stats.ManaRecoveryMultiplier));
         baseAttributeValues.Add(this.CreateConstValueAttribute(1, Stats.DamageReceiveDecrement));
         baseAttributeValues.Add(this.CreateConstValueAttribute(1, Stats.AttackDamageIncrease));
-        baseAttributeValues.Add(this.CreateConstValueAttribute(1, Stats.MoneyAmountRate));
         baseAttributeValues.Add(this.CreateConstValueAttribute(1, Stats.ExperienceRate));
         baseAttributeValues.Add(this.CreateConstValueAttribute(0.03f, Stats.PoisonDamageMultiplier));
         baseAttributeValues.Add(this.CreateConstValueAttribute(1, Stats.ItemDurationIncrease));
diff --git a/src/Persistence/Initialization/GameConfigurationInitializerBase.cs b/src/Persistence/Initialization/GameConfigurationInitializerBase.cs
index f62343be1..b0ad1538f 100644
--- a/src/Persistence/Initialization/GameConfigurationInitializerBase.cs
+++ b/src/Persistence/Initialization/GameConfigurationInitializerBase.cs
@@ -67,6 +67,7 @@ public override void Initialize()
         this.AddItemDropGroups();
 
         this.CreateStatAttributes();
+        this.AddGlobalBaseAttributeValues();
 
         new SlotTypesInitializer(this.Context, this.GameConfiguration).Initialize();
         this.CreateItemOptionTypes();
@@ -229,6 +230,15 @@ private void CreateStatAttributes()
         }
     }
 
+    /// <summary>
+    /// Adds the global base attribute values which apply to all characters.
+    /// </summary>
+    private void AddGlobalBaseAttributeValues()
+    {
+        var moneyAmountRate = this.Context.CreateNew<ConstValueAttribute>(1f, Stats.MoneyAmountRate.GetPersistent(this.GameConfiguration));
+        this.GameConfiguration.GlobalBaseAttributeValues.Add(moneyAmountRate);
+    }
+
     private long CalcNeededMasterExp(long lvl)
     {
         // f(x) = 505 * x^3 + 35278500 * x + 228045 * x^2
diff --git a/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugIn075.cs b/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugIn075.cs
new file mode 100644
index 000000000..d2087f4c9
--- /dev/null
+++ b/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugIn075.cs
@@ -0,0 +1,23 @@
+// <copyright file="AddGlobalMoneyAmountRateAttributePlugIn075.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Persistence.Initialization.Updates;
+
+using System.Runtime.InteropServices;
+using MUnique.OpenMU.PlugIns;
+
+/// <summary>
+/// This update moves the MoneyAmountRate attribute to global base attributes for version 0.75.
+/// </summary>
+[PlugIn]
+[Display(Name = PlugInName, Description = PlugInDescription)]
+[Guid("A1B2C3D4-E5F6-7890-ABCD-EF1234567890")]
+public class AddGlobalMoneyAmountRateAttributePlugIn075 : AddGlobalMoneyAmountRateAttributePlugInBase
+{
+    /// <inheritdoc />
+    public override UpdateVersion Version => UpdateVersion.AddGlobalMoneyAmountRateAttribute075;
+
+    /// <inheritdoc />
+    public override string DataInitializationKey => Version075.DataInitialization.Id;
+}
diff --git a/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugIn095d.cs b/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugIn095d.cs
new file mode 100644
index 000000000..9b9e927e9
--- /dev/null
+++ b/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugIn095d.cs
@@ -0,0 +1,23 @@
+// <copyright file="AddGlobalMoneyAmountRateAttributePlugIn095d.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Persistence.Initialization.Updates;
+
+using System.Runtime.InteropServices;
+using MUnique.OpenMU.PlugIns;
+
+/// <summary>
+/// This update moves the MoneyAmountRate attribute to global base attributes for version 0.95d.
+/// </summary>
+[PlugIn]
+[Display(Name = PlugInName, Description = PlugInDescription)]
+[Guid("B2C3D4E5-F6A7-8901-BCDE-F12345678901")]
+public class AddGlobalMoneyAmountRateAttributePlugIn095d : AddGlobalMoneyAmountRateAttributePlugInBase
+{
+    /// <inheritdoc />
+    public override UpdateVersion Version => UpdateVersion.AddGlobalMoneyAmountRateAttribute095d;
+
+    /// <inheritdoc />
+    public override string DataInitializationKey => Version095d.DataInitialization.Id;
+}
diff --git a/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugInBase.cs b/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugInBase.cs
new file mode 100644
index 000000000..d2fbf7e1d
--- /dev/null
+++ b/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugInBase.cs
@@ -0,0 +1,64 @@
+// <copyright file="AddGlobalMoneyAmountRateAttributePlugInBase.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Persistence.Initialization.Updates;
+
+using MUnique.OpenMU.AttributeSystem;
+using MUnique.OpenMU.DataModel.Configuration;
+using MUnique.OpenMU.GameLogic.Attributes;
+
+/// <summary>
+/// This update moves the <see cref="Stats.MoneyAmountRate"/> attribute from individual character class
+/// base attribute values to the global base attribute values of the game configuration.
+/// </summary>
+public abstract class AddGlobalMoneyAmountRateAttributePlugInBase : UpdatePlugInBase
+{
+    /// <summary>
+    /// The plug in name.
+    /// </summary>
+    internal const string PlugInName = "Add Global Money Amount Rate Attribute";
+
+    /// <summary>
+    /// The plug in description.
+    /// </summary>
+    internal const string PlugInDescription = "Moves the MoneyAmountRate attribute from character class base attributes to global base attributes.";
+
+    /// <inheritdoc />
+    public override string Name => PlugInName;
+
+    /// <inheritdoc />
+    public override string Description => PlugInDescription;
+
+    /// <inheritdoc />
+    public override bool IsMandatory => true;
+
+    /// <inheritdoc />
+    public override DateTime CreatedAt => new(2026, 03, 20, 20, 0, 0, DateTimeKind.Utc);
+
+    /// <inheritdoc />
+    protected override async ValueTask ApplyAsync(IContext context, GameConfiguration gameConfiguration)
+    {
+        var moneyAmountRateDef = gameConfiguration.Attributes.FirstOrDefault(a => a.Id == Stats.MoneyAmountRate.Id);
+        if (moneyAmountRateDef is null)
+        {
+            return;
+        }
+
+        if (!gameConfiguration.GlobalBaseAttributeValues.Any(a => a.Definition?.Id == Stats.MoneyAmountRate.Id))
+        {
+            var globalMoneyRate = context.CreateNew<ConstValueAttribute>(1f, moneyAmountRateDef);
+            gameConfiguration.GlobalBaseAttributeValues.Add(globalMoneyRate);
+        }
+
+        foreach (var characterClass in gameConfiguration.CharacterClasses)
+        {
+            var classMoneyRate = characterClass.BaseAttributeValues
+                .FirstOrDefault(a => a.Definition?.Id == Stats.MoneyAmountRate.Id);
+            if (classMoneyRate is not null)
+            {
+                characterClass.BaseAttributeValues.Remove(classMoneyRate);
+            }
+        }
+    }
+}
diff --git a/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugInSeason6.cs b/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugInSeason6.cs
new file mode 100644
index 000000000..1d1f2aa7d
--- /dev/null
+++ b/src/Persistence/Initialization/Updates/AddGlobalMoneyAmountRateAttributePlugInSeason6.cs
@@ -0,0 +1,23 @@
+// <copyright file="AddGlobalMoneyAmountRateAttributePlugInSeason6.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Persistence.Initialization.Updates;
+
+using System.Runtime.InteropServices;
+using MUnique.OpenMU.PlugIns;
+
+/// <summary>
+/// This update moves the MoneyAmountRate attribute to global base attributes for Season 6.
+/// </summary>
+[PlugIn]
+[Display(Name = PlugInName, Description = PlugInDescription)]
+[Guid("C3D4E5F6-A7B8-9012-CDEF-123456789012")]
+public class AddGlobalMoneyAmountRateAttributePlugInSeason6 : AddGlobalMoneyAmountRateAttributePlugInBase
+{
+    /// <inheritdoc />
+    public override UpdateVersion Version => UpdateVersion.AddGlobalMoneyAmountRateAttributeSeason6;
+
+    /// <inheritdoc />
+    public override string DataInitializationKey => VersionSeasonSix.DataInitialization.Id;
+}
diff --git a/src/Persistence/Initialization/Updates/UpdateVersion.cs b/src/Persistence/Initialization/Updates/UpdateVersion.cs
index 3af0fbb00..7a8012f08 100644
--- a/src/Persistence/Initialization/Updates/UpdateVersion.cs
+++ b/src/Persistence/Initialization/Updates/UpdateVersion.cs
@@ -367,4 +367,19 @@ public enum UpdateVersion
     /// The version of the <see cref="AddCrestOfMonarchDropGroupUpdateSeason6"/>.
     /// </summary>
     AddCrestOfMonarchDropGroupSeason6 = 72,
+
+    /// <summary>
+    /// The version of the <see cref="AddGlobalMoneyAmountRateAttributePlugIn075"/>.
+    /// </summary>
+    AddGlobalMoneyAmountRateAttribute075 = 73,
+
+    /// <summary>
+    /// The version of the <see cref="AddGlobalMoneyAmountRateAttributePlugIn095d"/>.
+    /// </summary>
+    AddGlobalMoneyAmountRateAttribute095d = 74,
+
+    /// <summary>
+    /// The version of the <see cref="AddGlobalMoneyAmountRateAttributePlugInSeason6"/>.
+    /// </summary>
+    AddGlobalMoneyAmountRateAttributeSeason6 = 75,
 }
diff --git a/tests/MUnique.OpenMU.Tests/TestHelper.cs b/tests/MUnique.OpenMU.Tests/TestHelper.cs
index b235eeccf..e8c1cd042 100644
--- a/tests/MUnique.OpenMU.Tests/TestHelper.cs
+++ b/tests/MUnique.OpenMU.Tests/TestHelper.cs
@@ -34,6 +34,11 @@ public static async ValueTask<Player> CreatePlayerAsync()
         gameConfig.Setup(c => c.Skills).Returns(new List<Skill>());
         gameConfig.Setup(c => c.PlugInConfigurations).Returns(new List<PlugInConfiguration>());
         gameConfig.Setup(c => c.CharacterClasses).Returns(new List<CharacterClass>());
+        gameConfig.Setup(c => c.GlobalAttributeCombinations).Returns(new List<AttributeRelationship>());
+        gameConfig.Setup(c => c.GlobalBaseAttributeValues).Returns(new List<ConstValueAttribute>
+        {
+            new(1, Stats.MoneyAmountRate),
+        });
         var map = new Mock<GameMapDefinition>();
         map.SetupAllProperties();
         map.Setup(m => m.DropItemGroups).Returns(new List<DropItemGroup>());
@@ -115,7 +120,6 @@ public static async ValueTask<Player> CreatePlayerAsync(IGameContext gameContext
             new (2, Stats.AbilityRecoveryMultiplier),
             new (1, Stats.DamageReceiveDecrement),
             new (1, Stats.AttackDamageIncrease),
-            new (1, Stats.MoneyAmountRate),
         });
         character.CharacterClass = characterClassMock.Object;