From 9948d1d6256660538a6f31183b2e2bd058361b84 Mon Sep 17 00:00:00 2001
From: revsys413 <revsys413@gmail.com>
Date: Wed, 3 Apr 2024 21:46:10 -0700
Subject: [PATCH] Adds CD records, height slider

---
 .../UI/Tabs/AdminTab/AdminTab.xaml            |    3 +
 .../Humanoid/HumanoidAppearanceSystem.cs      |   10 +
 .../Preferences/UI/HumanoidProfileEditor.xaml |    8 +
 .../UI/HumanoidProfileEditor.xaml.cs          |   91 +
 .../_CD/Admin/UI/ModifyCharacterRecords.xaml  |   14 +
 .../Admin/UI/ModifyCharacterRecords.xaml.cs   |   48 +
 ...haracterRecordConsoleBoundUserInterface.cs |   82 +
 .../_CD/Records/UI/CharacterRecordViewer.xaml |  117 ++
 .../Records/UI/CharacterRecordViewer.xaml.cs  |  361 ++++
 .../Records/UI/RecordEditorEntrySelector.xaml |   14 +
 .../UI/RecordEditorEntrySelector.xaml.cs      |  136 ++
 .../_CD/Records/UI/RecordEditorGui.xaml       |   68 +
 .../_CD/Records/UI/RecordEditorGui.xaml.cs    |  155 ++
 .../_CD/Records/UI/RecordEntryEditPopup.xaml  |   13 +
 .../Records/UI/RecordEntryEditPopup.xaml.cs   |   38 +
 .../_CD/Records/UI/RecordEntryViewPopup.xaml  |   19 +
 .../Records/UI/RecordEntryViewPopup.xaml.cs   |   34 +
 .../_CD/Records/UI/RecordLongItemDisplay.cs   |   65 +
 .../_CD/Records/UI/UnitConversion.cs          |   16 +
 .../Tests/Preferences/ServerDbSqliteTests.cs  |    6 +-
 .../20230711102742_Height.Designer.cs         | 1368 +++++++++++++
 .../Postgres/20230711102742_Height.cs         |   29 +
 ...40119204209_CDCharacterRecords.Designer.cs | 1764 +++++++++++++++++
 .../20240119204209_CDCharacterRecords.cs      |   29 +
 .../PostgresServerDbContextModelSnapshot.cs   |    8 +
 .../Sqlite/20230711102028_Height.Designer.cs  | 1300 ++++++++++++
 .../Sqlite/20230711102028_Height.cs           |   29 +
 ...40119204158_CDCharacterRecords.Designer.cs | 1696 ++++++++++++++++
 .../20240119204158_CDCharacterRecords.cs      |   28 +
 .../SqliteServerDbContextModelSnapshot.cs     |    8 +
 Content.Server.Database/Model.cs              |    5 +
 Content.Server.Database/ModelSqlite.cs        |    5 +
 .../Administration/Systems/AdminSystem.cs     |    9 +
 .../Systems/CriminalRecordsConsoleSystem.cs   |   16 +
 Content.Server/Database/ServerDbBase.cs       |   17 +-
 .../Systems/HumanoidAppearanceSystem.cs       |    1 +
 .../_CD/CryoSleep/CryoSleepSystem.cs          |  261 +++
 .../CharacterRecordKeyStorageComponent.cs     |   17 +
 .../_CD/Records/CharacterRecordsComponent.cs  |   31 +
 .../_CD/Records/CharacterRecordsSystem.cs     |  176 ++
 .../Records/Commands/DelRecordEntryCommand.cs |   55 +
 .../Commands/PurgeCharacterRecordsCommand.cs  |   42 +
 .../CharacterRecordConsoleComponent.cs        |   17 +
 .../Consoles/CharacterRecordConsoleSystem.cs  |  151 ++
 .../_CD/Records/RecordsSerialization.cs       |   92 +
 .../Humanoid/HumanoidAppearanceComponent.cs   |    6 +
 .../Humanoid/Prototypes/SpeciesPrototype.cs   |   44 +-
 .../SharedHumanoidAppearanceSystem.cs         |    2 +
 .../Preferences/HumanoidCharacterProfile.cs   |   61 +-
 .../_CD/Records/CharacterRecords.cs           |  252 +++
 .../_CD/Records/FullCharacterRecords.cs       |  109 +
 .../Records/SharedCharacterRecordConsole.cs   |   73 +
 Resources/Locale/en-US/_CD/admin/admin.ftl    |    4 +
 .../Locale/en-US/_CD/guidebook/guides.ftl     |    1 +
 .../Locale/en-US/_CD/records/corrections.ftl  |    5 +
 Resources/Locale/en-US/_CD/records/editor.ftl |   36 +
 Resources/Locale/en-US/_CD/records/viewer.ftl |   26 +
 .../ui/humanoid-profile-editor.ftl            |    2 +
 .../Entities/Mobs/Player/admin_ghost.yml      |   24 +-
 .../Entities/Mobs/Species/dwarf.yml           |    4 -
 .../Machines/Computers/computers.yml          |   50 +-
 Resources/Prototypes/Guidebook/ss14.yml       |   10 +
 Resources/Prototypes/Species/dwarf.yml        |    5 +
 .../ServerInfo/Guidebook/_CD/Records.xml      |   40 +
 64 files changed, 9164 insertions(+), 42 deletions(-)
 create mode 100644 Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml
 create mode 100644 Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/CharacterRecordConsoleBoundUserInterface.cs
 create mode 100644 Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml
 create mode 100644 Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml
 create mode 100644 Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordEditorGui.xaml
 create mode 100644 Content.Client/_CD/Records/UI/RecordEditorGui.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml
 create mode 100644 Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml
 create mode 100644 Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml.cs
 create mode 100644 Content.Client/_CD/Records/UI/RecordLongItemDisplay.cs
 create mode 100644 Content.Client/_CD/Records/UI/UnitConversion.cs
 create mode 100644 Content.Server.Database/Migrations/Postgres/20230711102742_Height.Designer.cs
 create mode 100644 Content.Server.Database/Migrations/Postgres/20230711102742_Height.cs
 create mode 100644 Content.Server.Database/Migrations/Postgres/20240119204209_CDCharacterRecords.Designer.cs
 create mode 100644 Content.Server.Database/Migrations/Postgres/20240119204209_CDCharacterRecords.cs
 create mode 100644 Content.Server.Database/Migrations/Sqlite/20230711102028_Height.Designer.cs
 create mode 100644 Content.Server.Database/Migrations/Sqlite/20230711102028_Height.cs
 create mode 100644 Content.Server.Database/Migrations/Sqlite/20240119204158_CDCharacterRecords.Designer.cs
 create mode 100644 Content.Server.Database/Migrations/Sqlite/20240119204158_CDCharacterRecords.cs
 create mode 100644 Content.Server/_CD/CryoSleep/CryoSleepSystem.cs
 create mode 100644 Content.Server/_CD/Records/CharacterRecordKeyStorageComponent.cs
 create mode 100644 Content.Server/_CD/Records/CharacterRecordsComponent.cs
 create mode 100644 Content.Server/_CD/Records/CharacterRecordsSystem.cs
 create mode 100644 Content.Server/_CD/Records/Commands/DelRecordEntryCommand.cs
 create mode 100644 Content.Server/_CD/Records/Commands/PurgeCharacterRecordsCommand.cs
 create mode 100644 Content.Server/_CD/Records/Consoles/CharacterRecordConsoleComponent.cs
 create mode 100644 Content.Server/_CD/Records/Consoles/CharacterRecordConsoleSystem.cs
 create mode 100644 Content.Server/_CD/Records/RecordsSerialization.cs
 create mode 100644 Content.Shared/_CD/Records/CharacterRecords.cs
 create mode 100644 Content.Shared/_CD/Records/FullCharacterRecords.cs
 create mode 100644 Content.Shared/_CD/Records/SharedCharacterRecordConsole.cs
 create mode 100644 Resources/Locale/en-US/_CD/admin/admin.ftl
 create mode 100644 Resources/Locale/en-US/_CD/guidebook/guides.ftl
 create mode 100644 Resources/Locale/en-US/_CD/records/corrections.ftl
 create mode 100644 Resources/Locale/en-US/_CD/records/editor.ftl
 create mode 100644 Resources/Locale/en-US/_CD/records/viewer.ftl
 create mode 100644 Resources/ServerInfo/Guidebook/_CD/Records.xml

diff --git a/Content.Client/Administration/UI/Tabs/AdminTab/AdminTab.xaml b/Content.Client/Administration/UI/Tabs/AdminTab/AdminTab.xaml
index 8b68487547f..b558d6114ed 100644
--- a/Content.Client/Administration/UI/Tabs/AdminTab/AdminTab.xaml
+++ b/Content.Client/Administration/UI/Tabs/AdminTab/AdminTab.xaml
@@ -3,6 +3,7 @@
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:cc="clr-namespace:Content.Client.Administration.UI.CustomControls"
     xmlns:at="clr-namespace:Content.Client.Administration.UI.Tabs.AdminTab"
+    xmlns:cdAdmin="clr-namespace:Content.Client._CD.Admin.UI"
     Margin="4"
     MinSize="50 50">
     <BoxContainer Orientation="Vertical">
@@ -16,6 +17,8 @@
             <cc:UICommandButton Command="callshuttle" Text="{Loc admin-player-actions-window-shuttle}" WindowType="{x:Type at:AdminShuttleWindow}"/>
             <cc:CommandButton Command="adminlogs" Text="{Loc admin-player-actions-window-admin-logs}"/>
             <cc:CommandButton Command="faxui" Text="{Loc admin-player-actions-window-admin-fax}"/>
+            <!-- CD: records purge button -->
+            <cc:UICommandButton Command="purgecharacterrecords" Text="{Loc admin-player-actions-window-cd-record-purge}" WindowType="{x:Type cdAdmin:ModifyCharacterRecords}"/>
         </GridContainer>
     </BoxContainer>
 </Control>
diff --git a/Content.Client/Humanoid/HumanoidAppearanceSystem.cs b/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
index 5bae35da5ba..f0b30601176 100644
--- a/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
+++ b/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
@@ -1,8 +1,10 @@
+using System.Numerics;
 using Content.Shared.Humanoid;
 using Content.Shared.Humanoid.Markings;
 using Content.Shared.Humanoid.Prototypes;
 using Content.Shared.Preferences;
 using Robust.Client.GameObjects;
+using Robust.Client.Console;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
 
@@ -12,6 +14,8 @@ public sealed class HumanoidAppearanceSystem : SharedHumanoidAppearanceSystem
 {
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly MarkingManager _markingManager = default!;
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly IClientConsoleHost _consoleHost = default!;
 
     public override void Initialize()
     {
@@ -30,6 +34,11 @@ private void UpdateSprite(HumanoidAppearanceComponent component, SpriteComponent
         UpdateLayers(component, sprite);
         ApplyMarkingSet(component, sprite);
 
+        var speciesPrototype = _prototypeManager.Index<SpeciesPrototype>(component.Species);
+        var height = Math.Clamp(MathF.Round(component.Height, 1), speciesPrototype.MinHeight, speciesPrototype.MaxHeight); // should NOT be locked, at all
+
+        sprite.Scale = new Vector2(speciesPrototype.ScaleHeight ? height : 1f, height);
+
         sprite[sprite.LayerMapReserveBlank(HumanoidVisualLayers.Eyes)].Color = component.EyeColor;
     }
 
@@ -194,6 +203,7 @@ public override void LoadProfile(EntityUid uid, HumanoidCharacterProfile profile
         humanoid.Species = profile.Species;
         humanoid.SkinColor = profile.Appearance.SkinColor;
         humanoid.EyeColor = profile.Appearance.EyeColor;
+        humanoid.Height = profile.Height;
 
         UpdateSprite(humanoid, Comp<SpriteComponent>(uid));
     }
diff --git a/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml b/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml
index d0dd02a58ad..15ce473c6ff 100644
--- a/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml
+++ b/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml
@@ -67,6 +67,14 @@
                                     <Control HorizontalExpand="True"/>
                                     <LineEdit Name="CAgeEdit" MinSize="40 0" HorizontalAlignment="Right" />
                                 </BoxContainer>
+                                <!-- CD Height -->
+                                <BoxContainer HorizontalExpand="True">
+                                    <Label Text="{Loc 'humanoid-profile-editor-height-label'}" />
+                                    <Control HorizontalExpand="True" />
+                                    <Slider Name="CDHeightSlider" HorizontalAlignment="Right" SetWidth="300" MinValue="0.0" MaxValue="1.0"/>
+                                    <LineEdit HorizontalAlignment="Right" Name="CHeight" MinSize="60 0" Text="1.0" />
+                                    <Button Name="CHeightReset" Text="{Loc 'humanoid-profile-editor-reset-height-button'}" HorizontalAlignment="Right"/>
+                                </BoxContainer>
                                 <!-- Sex -->
                                 <BoxContainer HorizontalExpand="True">
                                     <Label Text="{Loc 'humanoid-profile-editor-sex-label'}" />
diff --git a/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs b/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs
index 3e2e379328d..0afdc6ef991 100644
--- a/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs
+++ b/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs
@@ -1,3 +1,4 @@
+using System.Globalization;
 using System.Linq;
 using System.Numerics;
 using Content.Client.Guidebook;
@@ -36,6 +37,10 @@
 using static Robust.Client.UserInterface.Controls.BoxContainer;
 using Direction = Robust.Shared.Maths.Direction;
 
+// CD: Records editor imports
+using Content.Client._CD.Records.UI;
+using Content.Shared._CD.Records;
+
 namespace Content.Client.Preferences.UI
 {
     public sealed class HighlightedContainer : PanelContainer
@@ -78,6 +83,7 @@ public sealed partial class HumanoidProfileEditor : Control
         private SingleMarkingPicker _hairPicker => CHairStylePicker;
         private SingleMarkingPicker _facialHairPicker => CFacialHairPicker;
         private EyeColorPicker _eyesPicker => CEyeColorPicker;
+        private LineEdit _heightPicker => CHeight;
 
         private TabContainer _tabContainer => CTabContainer;
         private BoxContainer _jobList => CJobList;
@@ -108,6 +114,11 @@ public sealed partial class HumanoidProfileEditor : Control
 
         public event Action<HumanoidCharacterProfile, int>? OnProfileChanged;
 
+        private float _defaultHeight = 1f;
+
+        // CD: Record editor
+        private readonly RecordEditorGui _recordsTab;
+
         public HumanoidProfileEditor(IClientPreferencesManager preferencesManager, IPrototypeManager prototypeManager,
             IEntityManager entityManager, IConfigurationManager configurationManager)
         {
@@ -196,6 +207,41 @@ public HumanoidProfileEditor(IClientPreferencesManager preferencesManager, IProt
 
             #endregion Species
 
+            #region CDHeight
+
+            _heightPicker.OnTextChanged += args =>
+            {
+                if (Profile is null || !float.TryParse(args.Text, out var newHeight))
+                    return;
+
+                var prototype = _prototypeManager.Index<SpeciesPrototype>(Profile.Species);
+                newHeight = MathF.Round(Math.Clamp(newHeight, prototype.MinHeight, prototype.MaxHeight), 2);
+
+                // The percentage between the start and end numbers, aka "inverse lerp"
+                var sliderPercent = (newHeight - prototype.MinHeight) /
+                                    (prototype.MaxHeight - prototype.MinHeight);
+                CDHeightSlider.Value = sliderPercent;
+
+                SetProfileHeight(newHeight);
+            };
+
+            CHeightReset.OnPressed += _ =>
+            {
+                _heightPicker.SetText(_defaultHeight.ToString(CultureInfo.InvariantCulture), true);
+            };
+
+            CDHeightSlider.OnValueChanged += _ =>
+            {
+                if (Profile is null)
+                    return;
+                var prototype = _prototypeManager.Index<SpeciesPrototype>(Profile.Species);
+                var newHeight = MathF.Round(MathHelper.Lerp(prototype.MinHeight, prototype.MaxHeight, CDHeightSlider.Value), 2);
+                _heightPicker.Text = newHeight.ToString(CultureInfo.InvariantCulture);
+                SetProfileHeight(newHeight);
+            };
+
+            #endregion CDHeight
+
             #region Skin
 
 
@@ -481,6 +527,14 @@ public HumanoidProfileEditor(IClientPreferencesManager preferencesManager, IProt
 
             #endregion Markings
 
+            #region CosmaticRecords
+
+            _recordsTab = new RecordEditorGui(UpdateProfileRecords);
+            _tabContainer.AddChild(_recordsTab);
+            _tabContainer.SetTabTitle(_tabContainer.ChildCount - 1, Loc.GetString("humanoid-profile-editor-cd-records-tab"));
+
+            #endregion CosmaticRecords
+
             #region FlavorText
 
             if (_configurationManager.GetCVar(CCVars.FlavorText))
@@ -658,6 +712,15 @@ private void UpdateRoleRequirements()
             }
         }
 
+        // CD: Records editor
+        private void UpdateProfileRecords(CharacterRecords records)
+        {
+            if (Profile is null)
+                return;
+            Profile = Profile.WithCDCharacterRecords(records);
+            IsDirty = true;
+        }
+
         /// <summary>
         /// DeltaV - Make sure that no invalid job priorities get through.
         /// </summary>
@@ -869,6 +932,12 @@ private void SetBackpack(BackpackPreference newBackpack)
             IsDirty = true;
         }
 
+        private void SetProfileHeight(float height)
+        {
+            Profile = Profile?.WithHeight(height);
+            IsDirty = true;
+        }
+
         private void SetSpawnPriority(SpawnPriorityPreference newSpawnPriority)
         {
             Profile = Profile?.WithSpawnPriorityPreference(newSpawnPriority);
@@ -1069,6 +1138,24 @@ private void UpdateBackpackControls()
             _backpackButton.SelectId((int) Profile.Backpack);
         }
 
+        private void UpdateHeightControls()
+        {
+            if (Profile == null)
+            {
+                return;
+            }
+
+            var species = _speciesList.Find(x => x.ID == Profile.Species);
+            if (species != null)
+                _defaultHeight = species.DefaultHeight;
+
+            var prototype = _prototypeManager.Index<SpeciesPrototype>(Profile.Species);
+            var sliderPercent = (Profile.Height - prototype.MinHeight) /
+                                (prototype.MaxHeight - prototype.MinHeight);
+            CDHeightSlider.Value = sliderPercent;
+            _heightPicker.Text = Profile.Height.ToString(CultureInfo.InvariantCulture);
+        }
+
         private void UpdateSpawnPriorityControls()
         {
             if (Profile == null)
@@ -1230,6 +1317,10 @@ public void UpdateControls()
             UpdateHairPickers();
             UpdateCMarkingsHair();
             UpdateCMarkingsFacialHair();
+            UpdateHeightControls();
+
+            // CD: Update record editor
+            _recordsTab.Update(Profile);
 
             _preferenceUnavailableButton.SelectId((int) Profile.PreferenceUnavailable);
         }
diff --git a/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml b/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml
new file mode 100644
index 00000000000..9cb31849704
--- /dev/null
+++ b/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml
@@ -0,0 +1,14 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:cc="clr-namespace:Content.Client.Administration.UI.CustomControls"
+               Title="{Loc cd-actions-admin-modify-records}"
+               MinSize="300 300">
+    <BoxContainer Orientation="Vertical">
+        <LineEdit Name="EntityEdit" PlaceHolder="Entity" HorizontalExpand="True" />
+        <OptionButton Name="EntityEntryType" HorizontalExpand="True" />
+        <LineEdit Name="EntityEntryIndex" PlaceHolder="Index"/>
+        <BoxContainer Orientation="Horizontal" >
+            <cc:CommandButton Name="PurgeCommand" Text="{Loc cd-actions-admin-modify-reset}"/>
+            <cc:CommandButton Name="DelCommand" Text="{Loc cd-actions-admin-modify-del-entry}"/>
+        </BoxContainer>
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml.cs b/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml.cs
new file mode 100644
index 00000000000..9a868650997
--- /dev/null
+++ b/Content.Client/_CD/Admin/UI/ModifyCharacterRecords.xaml.cs
@@ -0,0 +1,48 @@
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client._CD.Admin.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ModifyCharacterRecords : DefaultWindow
+{
+    public ModifyCharacterRecords()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        foreach (var v in Enum.GetValues<CharacterRecordType>())
+        {
+            EntityEntryType.AddItem(v.ToString());
+        }
+
+        EntityEntryType.OnItemSelected += args =>
+        {
+            EntityEntryType.SelectId(args.Id);
+            UpdateCommands();
+        };
+
+        EntityEdit.OnTextChanged += _ => UpdateCommands();
+        EntityEntryIndex.OnTextChanged += _ => UpdateCommands();
+    }
+
+    private void UpdateCommands()
+    {
+        if (!int.TryParse(EntityEdit.Text, out var uid))
+        {
+            return;
+        }
+
+        if (!int.TryParse(EntityEntryIndex.Text, out var idx))
+        {
+            return;
+        }
+
+        var ty = (CharacterRecordType)EntityEntryType.SelectedId;
+
+        PurgeCommand.Command = $"purgecharacterrecords {uid}";
+        DelCommand.Command = $"delrecordentry {uid} {ty.ToString()} {idx}";
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/CharacterRecordConsoleBoundUserInterface.cs b/Content.Client/_CD/Records/UI/CharacterRecordConsoleBoundUserInterface.cs
new file mode 100644
index 00000000000..c1da4bdb331
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/CharacterRecordConsoleBoundUserInterface.cs
@@ -0,0 +1,82 @@
+using Content.Shared._CD.Records;
+using Content.Shared.CriminalRecords;
+using Content.Shared.CriminalRecords.Components;
+using Content.Shared.Security;
+using Content.Shared.StationRecords;
+using JetBrains.Annotations;
+
+namespace Content.Client._CD.Records.UI;
+
+[UsedImplicitly]
+public sealed class CharacterRecordConsoleBoundUserInterface : BoundUserInterface
+{
+    [ViewVariables] private CharacterRecordViewer? _window;
+
+    public CharacterRecordConsoleBoundUserInterface(EntityUid owner, Enum key)
+        : base(owner, key)
+    {
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState baseState)
+    {
+        base.UpdateState(baseState);
+        if (baseState is not CharacterRecordConsoleState state)
+            return;
+
+        if (_window?.IsSecurity() ?? false)
+        {
+            var comp = EntMan.GetComponent<CriminalRecordsConsoleComponent>(Owner);
+            _window!.SecurityWantedStatusMaxLength = comp.MaxStringLength;
+        }
+
+        _window?.UpdateState(state);
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = new();
+        _window.OnClose += Close;
+        _window.OnListingItemSelected += (ent, stationRecordKey) =>
+        {
+            SendMessage(new CharacterRecordConsoleSelectMsg(ent));
+
+            // If we are a security records console, we also need to inform the criminal records
+            // system of our state.
+            if (_window.IsSecurity() && stationRecordKey != null)
+            {
+                SendMessage(new SelectStationRecord(stationRecordKey));
+                _window.SetSecurityStatusEnabled(true);
+            }
+            else
+            {
+                // If the user does not have criminal records for some reason, we should not be able
+                // to set their wanted status
+                _window.SetSecurityStatusEnabled(false);
+            }
+        };
+
+        _window.OnFiltersChanged += (ty, txt) =>
+        {
+            if (txt == null)
+                SendMessage(new CharacterRecordsConsoleFilterMsg(null));
+            else
+                SendMessage(new CharacterRecordsConsoleFilterMsg(new StationRecordsFilter(ty, txt)));
+        };
+
+        _window.OnSetSecurityStatus += (status, reason) =>
+        {
+            SendMessage(new CriminalRecordChangeStatus(status, reason));
+        };
+
+        _window.OpenCentered();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        _window?.Close();
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml b/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml
new file mode 100644
index 00000000000..5728543d00e
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml
@@ -0,0 +1,117 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      xmlns:records="clr-namespace:Content.Client._CD.Records.UI"
+                      MinSize="850 750"
+                      SetSize="850 750" >
+    <BoxContainer Orientation="Vertical">
+        <!-- Search bar -->
+        <BoxContainer Margin="5 5 5 10" HorizontalExpand="true" VerticalAlignment="Center">
+            <OptionButton Name="RecordFilterType" MinWidth="200" Margin="0 0 10 0" Visible="False"/>
+            <!-- Yes, we do steal some localizations, should be fine -->
+            <LineEdit Name="RecordFiltersValue"
+                PlaceHolder="{Loc 'general-station-record-for-filter-line-placeholder'}" HorizontalExpand="True"/>
+            <Button Name="RecordFilters" Text="{Loc 'general-station-record-console-search-records'}"/>
+            <Button Name="RecordFiltersReset" Text="{Loc 'general-station-record-console-reset-filters'}"/>
+        </BoxContainer>
+        <BoxContainer VerticalExpand="True">
+            <!-- Record listing -->
+            <BoxContainer Orientation="Vertical" Margin="5" MinWidth="250" MaxWidth="250">
+                <Label Name="RecordListingStatus" Visible="False" />
+                <ScrollContainer VerticalExpand="True">
+                    <ItemList Name="RecordListing" />
+                </ScrollContainer>
+            </BoxContainer>
+            <!-- Record box -->
+            <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="5 5 10 10">
+                <Label Name="RecordContainerStatus" Visible="False" Text="{Loc 'cd-record-viewer-no-record-selected'}"/>
+                <BoxContainer Name="RecordContainer" Orientation="Vertical" Visible="False" >
+                    <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                        <!-- Common -->
+                        <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                            <Label Name="RecordContainerName" StyleClasses="LabelBig" />
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-age'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerAge" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-job'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerJob" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-gender'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerGender" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-species'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerSpecies" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'humanoid-profile-editor-cd-records-height'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerHeight" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'humanoid-profile-editor-cd-records-weight'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerWeight" Align="Right"/>
+                            </BoxContainer>
+                            <records:RecordLongItemDisplay Name="RecordContainerContactName" Title="{Loc 'humanoid-profile-editor-cd-records-contact-name'}"/>
+                        </BoxContainer>
+                        <!-- Employment -->
+                        <BoxContainer Name="RecordContainerEmployment" Orientation="Vertical" HorizontalExpand="True" Visible="False" >
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'humanoid-profile-editor-cd-records-work-authorization'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerWorkAuth" Align="Right" />
+                            </BoxContainer>
+                        </BoxContainer>
+                        <!-- Medical -->
+                        <BoxContainer Name="RecordContainerMedical" Orientation="Vertical" HorizontalExpand="True" Visible="False" >
+                            <records:RecordLongItemDisplay Name="RecordContainerAllergies" Title="{Loc 'humanoid-profile-editor-cd-records-allergies'}"/>
+                            <records:RecordLongItemDisplay Name="RecordContainerDrugAllergies" Title="{Loc 'humanoid-profile-editor-cd-records-drug-allergies'}"/>
+                            <records:RecordLongItemDisplay Name="RecordContainerPostmortem" Title="{Loc 'humanoid-profile-editor-cd-records-postmortem'}"/>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-med-sex'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerSex" Align="Right" />
+                            </BoxContainer>
+                        </BoxContainer>
+                        <!-- Security -->
+                        <BoxContainer Name="RecordContainerSecurity" Orientation="Vertical" HorizontalExpand="True" Visible="False" >
+                            <records:RecordLongItemDisplay Name="RecordContainerIdentFeatures" Title="{Loc 'humanoid-profile-editor-cd-records-identifying-features'}"/>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-sec-fingerprint'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerFingerprint" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                                <Label Text="{Loc 'cd-character-records-viewer-record-sec-dna'}"/>
+                                <Control HorizontalExpand="True" />
+                                <Label Name="RecordContainerDNA" Align="Right" />
+                            </BoxContainer>
+                            <BoxContainer Orientation="Horizontal" Margin="5 5 5 5">
+                                <Label Text="{Loc 'criminal-records-console-status'}" FontColorOverride="DarkGray"/>
+                                <OptionButton Name="StatusOptionButton"/>
+                                <Control MinWidth="5"/>
+                                <Label Name="RecordContainerWantedReason" Visible="False" />
+                            </BoxContainer>
+                        </BoxContainer>
+                    </BoxContainer>
+                    <!-- Entry viewer -->
+                    <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="10" SeparationOverride="5">
+                        <ItemList Name="RecordEntryList" HorizontalExpand="True" MinHeight="200" />
+                        <BoxContainer Orientation="Horizontal">
+                            <Button Name="RecordEntryViewButton" Text="{Loc 'cd-character-records-viewer-view-entry'}"/>
+                            <!-- Admin console entry type selector -->
+                            <OptionButton Name="RecordEntryViewType" />
+                        </BoxContainer>
+                    </BoxContainer>
+                </BoxContainer>
+            </BoxContainer>
+        </BoxContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml.cs b/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml.cs
new file mode 100644
index 00000000000..bba1390849b
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/CharacterRecordViewer.xaml.cs
@@ -0,0 +1,361 @@
+using System.Linq;
+using Content.Client.UserInterface.Controls;
+using Content.Shared._CD.Records;
+using Content.Shared.Administration;
+using Content.Shared.Security;
+using Content.Shared.StationRecords;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client._CD.Records.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class CharacterRecordViewer : FancyWindow
+{
+    public event Action<uint?, uint?>? OnListingItemSelected;
+    public event Action<StationRecordFilterType, string?>? OnFiltersChanged;
+
+    private bool _isPopulating;
+    private StationRecordFilterType _filterType;
+
+    private RecordConsoleType? _type;
+
+    private readonly RecordEntryViewPopup _entryView = new();
+    private List<CharacterRecords.RecordEntry>? _entries;
+
+    private DialogWindow? _wantedReasonDialog;
+    public event Action<SecurityStatus, string?>? OnSetSecurityStatus;
+
+    public uint? SecurityWantedStatusMaxLength;
+
+    public CharacterRecordViewer()
+    {
+        RobustXamlLoader.Load(this);
+
+        // There is no reason why we can't just steal the StationRecordFilter class.
+        // If wizden adds a new kind of filtering we want to replicate it here.
+        foreach (var item in Enum.GetValues<StationRecordFilterType>())
+        {
+            RecordFilterType.AddItem(GetTypeFilterLocals(item), (int)item);
+        }
+
+        // Again, if wizden changes something about Criminal Records, we want to replicate the
+        // functionality here.
+        foreach (var status in Enum.GetValues<SecurityStatus>())
+        {
+            var name = Loc.GetString($"criminal-records-status-{status.ToString().ToLower()}");
+            StatusOptionButton.AddItem(name, (int)status);
+        }
+
+        RecordListing.OnItemSelected += _ =>
+        {
+            if (!RecordListing.GetSelected().Any())
+                return;
+            var selected = RecordListing.GetSelected().First();
+            var (index, listingKey) = ((uint, uint?))selected.Metadata!;
+            OnListingItemSelected?.Invoke(index,  listingKey);
+        };
+
+        RecordListing.OnItemDeselected += _ =>
+        {
+            // When we populate the records, we clear the contents of the listing.
+            // This could cause a deselection but we don't want to really deselect because it would
+            // interrupt what the player is doing.
+            if (!_isPopulating)
+                OnListingItemSelected?.Invoke(null, null);
+        };
+
+        RecordFilters.OnPressed += _ =>
+        {
+            OnFiltersChanged?.Invoke(_filterType, RecordFiltersValue.Text);
+        };
+
+        RecordFiltersReset.OnPressed += _ =>
+        {
+            OnFiltersChanged?.Invoke(StationRecordFilterType.Name, null);
+            RecordFiltersValue.Clear();
+        };
+
+        RecordFiltersValue.OnTextEntered += text =>
+        {
+            OnFiltersChanged?.Invoke(_filterType, text.Text);
+        };
+
+        RecordFilterType.OnItemSelected += eventArgs =>
+        {
+            var type = (StationRecordFilterType)eventArgs.Id;
+            _filterType = type;
+            RecordFilterType.SelectId(eventArgs.Id);
+        };
+
+        RecordEntryViewButton.OnPressed += _ =>
+        {
+            if (_entries == null || !RecordEntryList.GetSelected().Any())
+                return;
+            int idx = RecordEntryList.IndexOf(RecordEntryList.GetSelected().First());
+            _entryView.SetContents(_entries[idx]);
+            _entryView.Open();
+        };
+
+        StatusOptionButton.OnItemSelected += args =>
+        {
+            var status = (SecurityStatus)args.Id;
+            // This should reflect SetStatus in CriminalRecordsConsoleWindow.xaml.cs
+            if (status == SecurityStatus.Wanted || status == SecurityStatus.Suspected)
+                SetStatusWithReason(status);
+            else
+                OnSetSecurityStatus?.Invoke(status, null);
+        };
+
+        OnClose += () => _entryView.Close();
+
+        // Admin console entry type selector
+        RecordEntryViewType.AddItem(Loc.GetString("department-Security"));
+        RecordEntryViewType.AddItem(Loc.GetString("department-Medical"));
+        RecordEntryViewType.AddItem(Loc.GetString("humanoid-profile-editor-cd-records-employment"));
+        RecordEntryViewType.OnItemSelected += args =>
+        {
+            RecordEntryViewType.SelectId(args.Id);
+            // This is a hack to get the server to send us another packet with the new entries
+            OnFiltersChanged?.Invoke(_filterType, RecordFiltersValue.Text);
+        };
+    }
+
+    // If we are using wizden's class we might as well use their localization.
+    private string GetTypeFilterLocals(StationRecordFilterType type)
+    {
+        return Loc.GetString($"general-station-record-{type.ToString().ToLower()}-filter");
+    }
+
+    public void UpdateState(CharacterRecordConsoleState state)
+    {
+        #region Visibility
+
+        RecordEntryViewType.Visible = false;
+        _type = state.ConsoleType;
+
+        // Disable listing if we don't have one selected
+        if (state.RecordListing == null)
+        {
+            RecordListingStatus.Visible = true;
+            RecordListing.Visible = false;
+            RecordListingStatus.Text = Loc.GetString("cd-record-viewer-empty-state");
+            RecordContainer.Visible = false;
+            RecordContainerStatus.Visible = false;
+            return;
+        }
+
+        RecordListingStatus.Visible = false;
+        RecordListing.Visible = true;
+
+        // Enable extended filtering only for admin and security consoles
+        switch (_type)
+        {
+            case RecordConsoleType.Employment:
+                RecordFilterType.Visible = false;
+                RecordFilterType.SelectId((int)StationRecordFilterType.Name);
+
+                Title = Loc.GetString("cd-character-records-viewer-title-employ");
+                break;
+            case RecordConsoleType.Medical:
+                RecordFilterType.Visible = false;
+                RecordFilterType.SelectId((int)StationRecordFilterType.Name);
+
+                Title = Loc.GetString("cd-character-records-viewer-title-med");
+                break;
+            case RecordConsoleType.Security:
+                RecordFilterType.Visible = true;
+
+                Title = Loc.GetString("cd-character-records-viewer-title-sec");
+                break;
+            case RecordConsoleType.Admin:
+                RecordFilterType.Visible = true;
+                Title = "Admin records console";
+                RecordEntryViewType.Visible = true;
+
+                break;
+        }
+
+        #endregion
+
+        #region PopulateListing
+
+        if (state.Filter != null)
+        {
+            RecordFiltersValue.SetText(state.Filter.Value);
+            RecordFilterType.SelectId((int) state.Filter.Type);
+        }
+
+        // If the counts are the same it is probably not needed to refresh the entry list. This provides
+        // a much better UI experience at the cost of the user possibly needing to re-open the UI under
+        // very specific circumstances that are *very* unlikely to appear in real gameplay.
+        if (RecordListing.Count != state.RecordListing.Count)
+        {
+            _isPopulating = true;
+
+            RecordListing.Clear();
+            foreach (var (key, (txt, stationRecordsKey)) in state.RecordListing)
+            {
+                RecordListing.AddItem(txt, metadata: (key, stationRecordsKey));
+            }
+
+            _isPopulating = false;
+        }
+
+        #endregion
+
+        #region FillRecordContainer
+
+        // Enable container if we have a record selected
+        if (state.SelectedRecord == null)
+        {
+            RecordContainerStatus.Visible = true;
+            RecordContainer.Visible = false;
+            return;
+        }
+
+        RecordContainerStatus.Visible = false;
+        RecordContainer.Visible = true;
+
+        var record = state.SelectedRecord!;
+        var cr = record.CharacterRecords;
+
+        // Basic info
+        RecordContainerName.Text = record.Name;
+        RecordContainerAge.Text = record.Age.ToString();
+        RecordContainerJob.Text = record.JobTitle; /* At some point in the future we might want to display the icon */
+        RecordContainerGender.Text = record.Gender.ToString();
+        RecordContainerSpecies.Text = record.Species;
+        RecordContainerHeight.Text = cr.Height + " " + UnitConversion.GetImperialDisplayLength(cr.Height);
+        RecordContainerWeight.Text = cr.Weight + " " + UnitConversion.GetImperialDisplayMass(cr.Weight);
+        RecordContainerContactName.SetValue(cr.EmergencyContactName);
+
+        RecordContainerEmployment.Visible = false;
+        RecordContainerMedical.Visible = false;
+        RecordContainerSecurity.Visible = false;
+
+        switch (_type)
+        {
+            case RecordConsoleType.Employment:
+                SetEntries(cr.EmploymentEntries);
+                UpdateRecordBoxEmployment(record);
+                break;
+            case RecordConsoleType.Medical:
+                SetEntries(cr.MedicalEntries);
+                UpdateRecordBoxMedical(record);
+                break;
+            case RecordConsoleType.Security:
+                SetEntries(cr.SecurityEntries);
+                UpdateRecordBoxSecurity(record, state.SelectedSecurityStatus);
+                break;
+            case RecordConsoleType.Admin:
+                UpdateRecordBoxEmployment(record);
+                UpdateRecordBoxMedical(record);
+                UpdateRecordBoxSecurity(record, state.SelectedSecurityStatus);
+                switch ((RecordConsoleType) RecordEntryViewType.SelectedId)
+                {
+                case RecordConsoleType.Employment:
+                    SetEntries(cr.EmploymentEntries, true);
+                    break;
+                case RecordConsoleType.Medical:
+                    SetEntries(cr.MedicalEntries, true);
+                    break;
+                case RecordConsoleType.Security:
+                    SetEntries(cr.SecurityEntries, true);
+                    break;
+                }
+                break;
+        }
+
+        #endregion
+
+    }
+
+    private void SetEntries(List<CharacterRecords.RecordEntry> entries, bool addIndex = false)
+    {
+        _entries = entries;
+        RecordEntryList.Clear();
+        var i = 0;
+        foreach (var entry in entries)
+        {
+            RecordEntryList.AddItem(addIndex ? $"({i.ToString()}) " + entry.Title : entry.Title);
+            ++i;
+        }
+    }
+
+    private void UpdateRecordBoxEmployment(FullCharacterRecords record)
+    {
+        RecordContainerEmployment.Visible = true;
+        RecordContainerWorkAuth.Text = record.CharacterRecords.HasWorkAuthorization ? "yes" : "no";
+    }
+
+    private void UpdateRecordBoxMedical(FullCharacterRecords record)
+    {
+        RecordContainerMedical.Visible = true;
+        var cr = record.CharacterRecords;
+        RecordContainerMedical.Visible = true;
+        RecordContainerAllergies.SetValue(cr.Allergies);
+        RecordContainerDrugAllergies.SetValue(cr.DrugAllergies);
+        RecordContainerPostmortem.SetValue(cr.PostmortemInstructions);
+        RecordContainerSex.Text = record.Sex.ToString();
+    }
+
+    private void UpdateRecordBoxSecurity(FullCharacterRecords record, (SecurityStatus, string?)? criminal)
+    {
+        RecordContainerSecurity.Visible = true;
+        RecordContainerIdentFeatures.SetValue(record.CharacterRecords.IdentifyingFeatures);
+        RecordContainerFingerprint.Text = record.Fingerprint ?? Loc.GetString("cd-character-records-viewer-unknown");
+        RecordContainerDNA.Text = record.DNA ?? Loc.GetString("cd-character-records-viewer-unknown");
+
+        RecordContainerWantedReason.Visible = false;
+        if (criminal != null)
+        {
+            var (stat, reason) = criminal.Value;
+            StatusOptionButton.Select((int)stat);
+            RecordContainerWantedReason.Text = reason;
+            RecordContainerWantedReason.Visible = reason != null;
+        }
+    }
+
+    // This is copied almost verbatim from CriminalRecordsConsoleWindow.xaml.cs
+    private void SetStatusWithReason(SecurityStatus status)
+    {
+        if (_wantedReasonDialog != null)
+        {
+            _wantedReasonDialog.MoveToFront();
+            return;
+        }
+
+        const string field = "reason";
+        var title = Loc.GetString("criminal-records-status-" + status.ToString().ToLower());
+        var placeholder = Loc.GetString("cd-character-records-viewer-setwanted-placeholder");
+        var prompt = Loc.GetString("criminal-records-console-reason");
+        var entry = new QuickDialogEntry(field, QuickDialogEntryType.LongText, prompt, placeholder);
+        var entries = new List<QuickDialogEntry>() { entry };
+        _wantedReasonDialog = new DialogWindow(title, entries);
+
+        _wantedReasonDialog.OnConfirmed += responses =>
+        {
+            var reason = responses[field];
+            if (reason.Length < 1 || reason.Length > SecurityWantedStatusMaxLength)
+                return;
+
+            OnSetSecurityStatus?.Invoke(status, reason);
+        };
+
+        _wantedReasonDialog.OnClose += () => { _wantedReasonDialog = null; };
+    }
+    public bool IsSecurity()
+    {
+        return _type == RecordConsoleType.Security || _type == RecordConsoleType.Admin;
+    }
+
+    public void SetSecurityStatusEnabled(bool setting)
+    {
+        for (var i = 0; i < StatusOptionButton.ItemCount; ++i)
+        {
+            StatusOptionButton.SetItemDisabled(i, !setting);
+        }
+    }
+}
+
diff --git a/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml b/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml
new file mode 100644
index 00000000000..328e36d0b86
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml
@@ -0,0 +1,14 @@
+<Control xmlns="https://spacestation14.io">
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True" VerticalExpand="True">
+        <ItemList Name="EntrySelector" HorizontalExpand="True" VerticalExpand="True" MinSize="300 200" />
+        <BoxContainer Orientation="Horizontal">
+            <Button Name="AddButton" StyleClasses="OpenBoth" Text="{Loc 'humanoid-profile-editor-cd-records-add-entry'}" />
+            <Button Name="EditButton" StyleClasses="OpenBoth" Text="{Loc 'humanoid-profile-editor-cd-records-edit-entry'}" />
+            <Button Name="ViewButton" StyleClasses="OpenBoth" Text="{Loc 'humanoid-profile-editor-cd-records-view-entry'}" />
+            <Button Name="RemoveButton" StyleClasses="OpenLeft" Text="{Loc 'humanoid-profile-editor-cd-records-remove-entry'}" />
+            <Control HorizontalExpand="True" />
+            <Button Name="UpButton" HorizontalAlignment="Right" StyleClasses="OpenRight" Text="{Loc 'humanoid-profile-editor-cd-records-up'}" />
+            <Button Name="DownButton" HorizontalAlignment="Right" StyleClasses="OpenBoth" Text="{Loc 'humanoid-profile-editor-cd-records-down'}" />
+        </BoxContainer>
+    </BoxContainer>
+</Control>
diff --git a/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml.cs b/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml.cs
new file mode 100644
index 00000000000..61d569625b4
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEditorEntrySelector.xaml.cs
@@ -0,0 +1,136 @@
+using System.Linq;
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client._CD.Records.UI;
+
+/// <summary>
+/// The box that contains the list of entities in the record editor. We create one for each record type
+/// </summary>
+[GenerateTypedNameReferences]
+public sealed partial class RecordEditorEntrySelector : Control
+{
+    private List<CharacterRecords.RecordEntry> _entries = new();
+
+    public event Action<RecordEditorEntryUpdateArgs>? OnUpdateEntries;
+
+    private readonly RecordEntryEditPopup _editPopup = new();
+    private readonly RecordEntryViewPopup _entryViewPopup = new();
+    private int _editIdx;
+
+    public RecordEditorEntrySelector()
+    {
+        RobustXamlLoader.Load(this);
+
+        AddButton.OnPressed += _ =>
+        {
+            _editIdx = _entries.Count;
+            _editPopup.SetContents(new CharacterRecords.RecordEntry("", "", ""));
+            _editPopup.Open();
+        };
+
+        EditButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            _editIdx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            _editPopup.SetContents(_entries[_editIdx]);
+            _editPopup.Open();
+        };
+
+        ViewButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            var idx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            _entryViewPopup.SetContents(_entries[idx]);
+            _entryViewPopup.Open();
+        };
+
+        RemoveButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            // Remove the entry, being careful to set the index correctly
+            int idx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            EntrySelector.RemoveAt(idx);
+            _entries.RemoveAt(idx);
+            if (idx == _editIdx)
+                _editPopup.Close();
+            _editIdx--;
+            OnUpdateEntries?.Invoke(new RecordEditorEntryUpdateArgs(_entries));
+        };
+
+        UpButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            int idx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            if (idx < 1)
+                return;
+            (_entries[idx], _entries[idx - 1]) = (_entries[idx - 1], _entries[idx]);
+            (EntrySelector[idx], EntrySelector[idx - 1]) = (EntrySelector[idx - 1], EntrySelector[idx]);
+            OnUpdateEntries?.Invoke(new RecordEditorEntryUpdateArgs(_entries));
+        };
+
+        DownButton.OnPressed += _ =>
+        {
+            if (!EntrySelector.GetSelected().Any())
+                return;
+            int idx = EntrySelector.IndexOf(EntrySelector.GetSelected().First());
+            if (idx >= EntrySelector.Count - 1)
+                return;
+            (_entries[idx], _entries[idx + 1]) = (_entries[idx + 1], _entries[idx]);
+            (EntrySelector[idx], EntrySelector[idx + 1]) = (EntrySelector[idx + 1], EntrySelector[idx]);
+            OnUpdateEntries?.Invoke(new RecordEditorEntryUpdateArgs(_entries));
+        };
+
+        _editPopup.SaveButton.OnPressed += _ =>
+        {
+            if (_editIdx >= _entries.Count)
+            {
+                var rec = _editPopup.GetContents();
+                _entries.Add(rec);
+                EntrySelector.AddItem(rec.Title);
+            }
+            else
+            {
+                _entries[_editIdx] = _editPopup.GetContents();
+                EntrySelector[_editIdx].Text = _entries[_editIdx].Title;
+            }
+            OnUpdateEntries?.Invoke(new RecordEditorEntryUpdateArgs(_entries));
+        };
+        OnVisibilityChanged += _ =>
+        {
+            _editPopup.Close();
+        };
+    }
+
+    public void UpdateContents(List<CharacterRecords.RecordEntry> entries)
+    {
+        _entries = entries;
+        RefreshSelector();
+    }
+
+    private void RefreshSelector()
+    {
+        EntrySelector.Clear();
+        foreach (var entry in _entries)
+        {
+            EntrySelector.AddItem(entry.Title);
+        }
+    }
+
+    public sealed class RecordEditorEntryUpdateArgs
+    {
+        public List<CharacterRecords.RecordEntry> Entries { get; private set; }
+
+        public RecordEditorEntryUpdateArgs(List<CharacterRecords.RecordEntry> entries)
+        {
+            Entries = entries;
+        }
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/RecordEditorGui.xaml b/Content.Client/_CD/Records/UI/RecordEditorGui.xaml
new file mode 100644
index 00000000000..40ba43c8b50
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEditorGui.xaml
@@ -0,0 +1,68 @@
+<Control xmlns="https://spacestation14.io"
+         xmlns:cdrecords="clr-namespace:Content.Client._CD.Records.UI">
+    <BoxContainer Orientation="Vertical">
+         <ScrollContainer VerticalExpand="True">
+             <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="10">
+                 <!-- Height, Weight -->
+                 <GridContainer Columns="2">
+                     <BoxContainer HorizontalExpand="True" SeparationOverride="2">
+                         <Label Text="{Loc 'humanoid-profile-editor-cd-records-height'}" />
+                         <Control HorizontalExpand="True" MinSize="5 0" />
+                         <LineEdit Name="HeightEdit" HorizontalAlignment="Right" MinSize="60 0" />
+                         <Label Name="HeightImperialLabel" MinWidth="60" />
+                     </BoxContainer>
+                     <BoxContainer HorizontalExpand="True" SeparationOverride="2">
+                         <Label Text="{Loc 'humanoid-profile-editor-cd-records-weight'}" />
+                         <Control HorizontalExpand="True" MinSize="5 0" />
+                         <LineEdit Name="WeightEdit" HorizontalAlignment="Right" MinSize="60 0" />
+                         <Label Name="WeightImperialLabel" MinWidth="70"/>
+                     </BoxContainer>
+                 </GridContainer>
+                 <!-- Emergency Contact -->
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-contact-name'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="ContactNameEdit" HorizontalAlignment="Right" MinSize="270 0"/>
+                 </BoxContainer>
+                 <Control MinSize="0 20"/>
+                 <!-- Employment stuff -->
+                 <BoxContainer HorizontalExpand="True">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-work-authorization'}" />
+                     <Control HorizontalExpand="True" MinSize="5 0" />
+                     <CheckBox Name="WorkAuthCheckBox" HorizontalAlignment="Right"/>
+                 </BoxContainer>
+                 <Control MinSize="0 20"/>
+                 <!-- Security stuff -->
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-identifying-features'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="IdentifyingFeaturesEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <Control MinSize="0 20"/>
+                 <!-- Medical stuff -->
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-allergies'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="AllergiesEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-drug-allergies'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="DrugAllergiesEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <BoxContainer Orientation="Horizontal">
+                     <Label Text="{Loc 'humanoid-profile-editor-cd-records-postmortem'}" />
+                     <Control HorizontalExpand="True" />
+                     <LineEdit Name="PostmortemEdit" HorizontalAlignment="Right" MinSize="350 0"/>
+                 </BoxContainer>
+                 <Control MinSize="0 20"/>
+                 <!-- Entry editor -->
+                 <TabContainer Name="EntryEditorTabs" VerticalExpand="True" HorizontalExpand="True" Margin="10">
+                     <cdrecords:RecordEditorEntrySelector Name="EmploymentEntrySelector"/>
+                     <cdrecords:RecordEditorEntrySelector Name="MedicalEntrySelector"/>
+                     <cdrecords:RecordEditorEntrySelector Name="SecurityEntrySelector"/>
+                 </TabContainer>
+             </BoxContainer>
+         </ScrollContainer>
+    </BoxContainer>
+</Control>
diff --git a/Content.Client/_CD/Records/UI/RecordEditorGui.xaml.cs b/Content.Client/_CD/Records/UI/RecordEditorGui.xaml.cs
new file mode 100644
index 00000000000..631a68ea815
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEditorGui.xaml.cs
@@ -0,0 +1,155 @@
+using Content.Shared._CD.Records;
+using Content.Shared.Preferences;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client._CD.Records.UI;
+
+/// <summary>
+/// The record editor tab that gets "injected" into the character editor.
+/// </summary>
+[GenerateTypedNameReferences]
+public sealed partial class RecordEditorGui : Control
+{
+    /// <summary>
+    /// Delegate that tells the editor to save records when the save button is pressed
+    /// </summary>
+    private readonly Action<CharacterRecords> _updateProfileRecords;
+    private CharacterRecords _records = default!;
+
+    public RecordEditorGui(Action<CharacterRecords> updateProfileRecords)
+    {
+        RobustXamlLoader.Load(this);
+        _updateProfileRecords = updateProfileRecords;
+
+        #region General
+
+        HeightEdit.OnTextChanged += args =>
+        {
+            if (!int.TryParse(args.Text, out var newHeight))
+                return;
+            UpdateImperialHeight(newHeight);
+            UpdateRecords(_records.WithHeight(newHeight));
+        };
+
+        WeightEdit.OnTextChanged += args =>
+        {
+            if (!int.TryParse(args.Text, out var newWeight))
+                return;
+            UpdateImperialWeight(newWeight);
+            UpdateRecords(_records.WithWeight(newWeight));
+        };
+
+        ContactNameEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithContactName(args.Text));
+        };
+
+        #endregion
+
+        #region Employment
+
+        WorkAuthCheckBox.OnToggled += args =>
+        {
+            UpdateRecords(_records.WithWorkAuth(args.Pressed));
+        };
+
+        #endregion
+
+        #region Security
+
+        IdentifyingFeaturesEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithIdentifyingFeatures(args.Text));
+        };
+
+        #endregion
+
+        #region Medical
+
+        AllergiesEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithAllergies(args.Text));
+        };
+
+        DrugAllergiesEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithDrugAllergies(args.Text));
+        };
+
+        PostmortemEdit.OnTextChanged += args =>
+        {
+            UpdateRecords(_records.WithPostmortemInstructions(args.Text));
+        };
+
+        #endregion
+
+        #region Entries
+
+        EntryEditorTabs.SetTabTitle(0, Loc.GetString("humanoid-profile-editor-cd-records-employment"));
+        EntryEditorTabs.SetTabTitle(1, Loc.GetString("department-Medical"));
+        EntryEditorTabs.SetTabTitle(2, Loc.GetString("department-Security"));
+
+        EmploymentEntrySelector.OnUpdateEntries += args =>
+        {
+            UpdateRecords(_records.WithEmploymentEntries(args.Entries));
+        };
+
+        MedicalEntrySelector.OnUpdateEntries += args =>
+        {
+            UpdateRecords(_records.WithMedicalEntries(args.Entries));
+        };
+
+        SecurityEntrySelector.OnUpdateEntries += args =>
+        {
+            UpdateRecords(_records.WithSecurityEntries(args.Entries));
+        };
+
+        #endregion
+    }
+
+    public void Update(HumanoidCharacterProfile profile)
+    {
+        _records = profile.CDCharacterRecords ?? CharacterRecords.DefaultRecords();
+        EmploymentEntrySelector.UpdateContents(_records.EmploymentEntries);
+        MedicalEntrySelector.UpdateContents(_records.MedicalEntries);
+        SecurityEntrySelector.UpdateContents(_records.SecurityEntries);
+        UpdateWidgets();
+    }
+
+    private void UpdateRecords(CharacterRecords records)
+    {
+        records.EnsureValid();
+        _records = records;
+        _updateProfileRecords(_records);
+        UpdateWidgets();
+    }
+
+    private void UpdateWidgets()
+    {
+        HeightEdit.SetText(_records.Height.ToString());
+        UpdateImperialHeight(_records.Height);
+        WeightEdit.SetText(_records.Weight.ToString());
+        UpdateImperialWeight(_records.Weight);
+        ContactNameEdit.SetText(_records.EmergencyContactName);
+
+        WorkAuthCheckBox.Pressed = _records.HasWorkAuthorization;
+
+        IdentifyingFeaturesEdit.SetText(_records.IdentifyingFeatures);
+
+        AllergiesEdit.SetText(_records.Allergies);
+        DrugAllergiesEdit.SetText(_records.DrugAllergies);
+        PostmortemEdit.SetText(_records.PostmortemInstructions);
+    }
+
+    private void UpdateImperialHeight(int newHeight)
+    {
+        HeightImperialLabel.Text = UnitConversion.GetImperialDisplayLength(newHeight);
+    }
+
+    private void UpdateImperialWeight(int newWeight)
+    {
+        WeightImperialLabel.Text = UnitConversion.GetImperialDisplayMass(newWeight);
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml b/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml
new file mode 100644
index 00000000000..c1855152a5d
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml
@@ -0,0 +1,13 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      MinSize="500 700"
+                      Title="{Loc 'cd-records-entry-edit-popup-title'}">
+    <BoxContainer Margin="10" Orientation="Vertical" HorizontalExpand="True" SeparationOverride="5">
+        <LineEdit Name="TitleEdit" HorizontalExpand="True" PlaceHolder="{Loc 'cd-records-entry-edit-popup-title-placeholder'}"/>
+        <LineEdit Name="InvolvedEdit" HorizontalExpand="True" PlaceHolder="{Loc 'cd-records-entry-edit-popup-involved-placeholder'}"/>
+        <TextEdit Name="DescriptionEdit" HorizontalExpand="True" VerticalExpand="True" StyleClasses="BackgroundDark" />
+        <PanelContainer StyleClasses="BackgroundDark">
+            <Button Access="Public" Name="SaveButton" Text="{Loc 'cd-records-entry-edit-popup-save'}"/>
+        </PanelContainer>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml.cs b/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml.cs
new file mode 100644
index 00000000000..84cbc123da8
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEntryEditPopup.xaml.cs
@@ -0,0 +1,38 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Utility;
+
+namespace Content.Client._CD.Records.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class RecordEntryEditPopup : FancyWindow
+{
+    public RecordEntryEditPopup()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        DescriptionEdit.Placeholder =
+            new Rope.Leaf(Loc.GetString("cd-records-entry-edit-popup-description-placeholder"));
+
+        SaveButton.OnPressed += _ =>
+        {
+            Close();
+        };
+    }
+
+    public CharacterRecords.RecordEntry GetContents()
+    {
+        string desc = Rope.Collapse(DescriptionEdit.TextRope).Trim();
+        return new CharacterRecords.RecordEntry(TitleEdit.Text, InvolvedEdit.Text, desc);
+    }
+
+    public void SetContents(CharacterRecords.RecordEntry entry)
+    {
+        TitleEdit.Text = entry.Title;
+        InvolvedEdit.Text = entry.Involved;
+        DescriptionEdit.TextRope = new Rope.Leaf(entry.Description);
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml b/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml
new file mode 100644
index 00000000000..2c8388e8f44
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml
@@ -0,0 +1,19 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      MinSize="500 700"
+                      SetSize="600 700"
+                      Title="{Loc 'cd-records-entry-view-popup-title'}">
+    <BoxContainer Margin="10" Orientation="Vertical" HorizontalExpand="True" SeparationOverride="5">
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True" >
+            <Label Text="{Loc 'cd-character-records-entry-view-title'}" StyleClasses="LabelBig"/>
+            <Control MinWidth="5"/>
+            <RichTextLabel HorizontalAlignment="Right" Name="EntryTitle" HorizontalExpand="True" StyleClasses="LabelBig" />
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True" >
+            <Label Text="{Loc 'cd-character-records-entry-view-involved'}" StyleClasses="LabelBig"/>
+            <Control MinWidth="5"/>
+            <RichTextLabel HorizontalAlignment="Right" Name="EntryInvolved" HorizontalExpand="True" StyleClasses="LabelBig"/>
+        </BoxContainer>
+        <RichTextLabel Name="EntryDesc" HorizontalExpand="True" VerticalExpand="True" VerticalAlignment="Stretch"/>
+    </BoxContainer>
+</controls:FancyWindow>
diff --git a/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml.cs b/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml.cs
new file mode 100644
index 00000000000..73ce0a6eab4
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordEntryViewPopup.xaml.cs
@@ -0,0 +1,34 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared._CD.Records;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.RichText;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Utility;
+
+namespace Content.Client._CD.Records.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class RecordEntryViewPopup : FancyWindow
+{
+    // We don't permit headings because it looks ugly
+    private static readonly Type[] AllowedTags =
+    {
+        typeof(BoldItalicTag),
+        typeof(BoldTag),
+        typeof(BulletTag),
+        typeof(ColorTag),
+        typeof(ItalicTag)
+    };
+
+    public RecordEntryViewPopup()
+    {
+        RobustXamlLoader.Load(this);
+    }
+
+    public void SetContents(CharacterRecords.RecordEntry entry)
+    {
+        EntryTitle.SetMessage(entry.Title);
+        EntryInvolved.SetMessage(entry.Involved);
+        EntryDesc.SetMessage(FormattedMessage.FromMarkupPermissive(entry.Description.Trim()), AllowedTags);
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/RecordLongItemDisplay.cs b/Content.Client/_CD/Records/UI/RecordLongItemDisplay.cs
new file mode 100644
index 00000000000..7eca7114f71
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/RecordLongItemDisplay.cs
@@ -0,0 +1,65 @@
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+
+namespace Content.Client._CD.Records.UI;
+
+/// <summary>
+/// Widget that displays the record on one line if it is short enough, and on two lines if it is
+/// too long. This should only be used if you know the length may be long enough to break things when
+/// using a normal Label.
+/// </summary>
+public sealed class RecordLongItemDisplay : BoxContainer
+{
+    private const int MaxShortLength = 32;
+
+    public string? Title
+    {
+        get => _titleLabel.Text;
+        set => _titleLabel.Text = value;
+    }
+
+    // Row containing the title and short value
+    private readonly BoxContainer _firstRow = new()
+    {
+        Orientation = LayoutOrientation.Horizontal,
+        HorizontalExpand = true
+    };
+    // Row containing the long value
+    private readonly BoxContainer _secondRow = new()
+    {
+        Orientation = LayoutOrientation.Horizontal,
+        HorizontalExpand = true,
+        Visible = false,
+    };
+    private readonly Label _titleLabel = new();
+    private readonly Label _shortContents = new() { Visible = true, Align = Label.AlignMode.Right };
+    private readonly RichTextLabel _longContents = new() { HorizontalExpand = true };
+
+    public RecordLongItemDisplay()
+    {
+        Orientation = LayoutOrientation.Vertical;
+        _firstRow.AddChild(_titleLabel);
+        _firstRow.AddChild(new Control() { HorizontalExpand = true });
+        _firstRow.AddChild(_shortContents);
+        AddChild(_firstRow);
+        _secondRow.AddChild(new Control() { HorizontalExpand = true, SizeFlagsStretchRatio = 0.15f});
+        _secondRow.AddChild(_longContents);
+        AddChild(_secondRow);
+    }
+
+    public void SetValue(string s)
+    {
+        if (s.Length > MaxShortLength)
+        {
+            _longContents.SetMessage(s);
+            _secondRow.Visible = true;
+            _shortContents.Visible = false;
+        }
+        else
+        {
+            _shortContents.Text = s;
+            _shortContents.Visible = true;
+            _secondRow.Visible = false;
+        }
+    }
+}
diff --git a/Content.Client/_CD/Records/UI/UnitConversion.cs b/Content.Client/_CD/Records/UI/UnitConversion.cs
new file mode 100644
index 00000000000..22a852f2a92
--- /dev/null
+++ b/Content.Client/_CD/Records/UI/UnitConversion.cs
@@ -0,0 +1,16 @@
+namespace Content.Client._CD.Records.UI;
+
+public static class UnitConversion
+{
+    public static string GetImperialDisplayLength(int lengthCm)
+    {
+        int heightIn = (int) Math.Round(lengthCm * 0.3937007874 /* cm to in*/);
+        return $"({heightIn / 12}'{heightIn % 12}'')";
+    }
+
+    public static string GetImperialDisplayMass(int massKg)
+    {
+        int weightLbs = (int) Math.Round(massKg * 2.2046226218 /* kg to lbs */);
+        return $"({weightLbs} lbs)";
+    }
+}
diff --git a/Content.IntegrationTests/Tests/Preferences/ServerDbSqliteTests.cs b/Content.IntegrationTests/Tests/Preferences/ServerDbSqliteTests.cs
index c57504764dc..286f92ffafc 100644
--- a/Content.IntegrationTests/Tests/Preferences/ServerDbSqliteTests.cs
+++ b/Content.IntegrationTests/Tests/Preferences/ServerDbSqliteTests.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Content.Server.Database;
+using Content.Shared._CD.Records;
 using Content.Shared.GameTicking;
 using Content.Shared.Humanoid;
 using Content.Shared.Preferences;
@@ -41,6 +42,7 @@ private static HumanoidCharacterProfile CharlieCharlieson()
                 "Charlie Charlieson",
                 "The biggest boy around.",
                 "Human",
+                1,
                 21,
                 Sex.Male,
                 Gender.Epicene,
@@ -62,7 +64,9 @@ private static HumanoidCharacterProfile CharlieCharlieson()
                 },
                 PreferenceUnavailableMode.StayInLobby,
                 new List<string> (),
-                new List<string>()
+                new List<string>(),
+                // CD: test records
+                CharacterRecords.DefaultRecords()
             );
         }
 
diff --git a/Content.Server.Database/Migrations/Postgres/20230711102742_Height.Designer.cs b/Content.Server.Database/Migrations/Postgres/20230711102742_Height.Designer.cs
new file mode 100644
index 00000000000..c932ec93a64
--- /dev/null
+++ b/Content.Server.Database/Migrations/Postgres/20230711102742_Height.Designer.cs
@@ -0,0 +1,1368 @@
+// <auto-generated />
+using System;
+using System.Net;
+using System.Text.Json;
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    [DbContext(typeof(PostgresServerDbContext))]
+    [Migration("20230711102742_Height")]
+    partial class Height
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "7.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<int?>("AdminRankId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text")
+                        .HasColumnName("title");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_admin");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_admin_rank_id");
+
+                    b.ToTable("admin", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_flag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AdminId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("admin_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flag");
+
+                    b.Property<bool>("Negative")
+                        .HasColumnType("boolean")
+                        .HasColumnName("negative");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_flag");
+
+                    b.HasIndex("AdminId")
+                        .HasDatabaseName("IX_admin_flag_admin_id");
+
+                    b.HasIndex("Flag", "AdminId")
+                        .IsUnique();
+
+                    b.ToTable("admin_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("date");
+
+                    b.Property<short>("Impact")
+                        .HasColumnType("smallint")
+                        .HasColumnName("impact");
+
+                    b.Property<JsonDocument>("Json")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("json");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("message");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id", "RoundId")
+                        .HasName("PK_admin_log");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Message")
+                        .HasAnnotation("Npgsql:TsVectorConfig", "english");
+
+                    NpgsqlIndexBuilderExtensions.HasMethod(b.HasIndex("Message"), "GIN");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_log_round_id");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_admin_log_type");
+
+                    b.ToTable("admin_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogEntity", b =>
+                {
+                    b.Property<int>("Uid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("uid");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Uid"));
+
+                    b.Property<int?>("AdminLogId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<int?>("AdminLogRoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_log_round_id");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Uid")
+                        .HasName("PK_admin_log_entity");
+
+                    b.HasIndex("AdminLogId", "AdminLogRoundId")
+                        .HasDatabaseName("IX_admin_log_entity_admin_log_id_admin_log_round_id");
+
+                    b.ToTable("admin_log_entity", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<int>("LogId")
+                        .HasColumnType("integer")
+                        .HasColumnName("log_id");
+
+                    b.Property<int>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("PlayerUserId", "LogId", "RoundId")
+                        .HasName("PK_admin_log_player");
+
+                    b.HasIndex("LogId", "RoundId");
+
+                    b.ToTable("admin_log_player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_notes_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid>("CreatedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime>("LastEditedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("message");
+
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("ShownToPlayer")
+                        .HasColumnType("boolean")
+                        .HasColumnName("shown_to_player");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_notes");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_notes_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_notes_round_id");
+
+                    b.ToTable("admin_notes", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank");
+
+                    b.ToTable("admin_rank", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_flag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AdminRankId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flag");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank_flag");
+
+                    b.HasIndex("AdminRankId");
+
+                    b.HasIndex("Flag", "AdminRankId")
+                        .IsUnique();
+
+                    b.ToTable("admin_rank_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("antag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("antag_name");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_antag");
+
+                    b.HasIndex("ProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("antag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AssignedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("assigned_user_id_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_assigned_user_id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("assigned_user_id", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("connection_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<IPAddress>("Address")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<byte?>("Denied")
+                        .HasColumnType("smallint")
+                        .HasColumnName("denied");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("time");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_connection_log");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("connection_log", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("job_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer")
+                        .HasColumnName("priority");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_job");
+
+                    b.HasIndex("ProfileId");
+
+                    b.HasIndex("ProfileId", "JobName")
+                        .IsUnique();
+
+                    b.HasIndex(new[] { "ProfileId" }, "IX_job_one_high_priority")
+                        .IsUnique()
+                        .HasFilter("priority = 3");
+
+                    b.ToTable("job", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.PlayTime", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("play_time_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("PlayerId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_id");
+
+                    b.Property<TimeSpan>("TimeSpent")
+                        .HasColumnType("interval")
+                        .HasColumnName("time_spent");
+
+                    b.Property<string>("Tracker")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("tracker");
+
+                    b.HasKey("Id")
+                        .HasName("PK_play_time");
+
+                    b.HasIndex("PlayerId", "Tracker")
+                        .IsUnique();
+
+                    b.ToTable("play_time", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("player_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("FirstSeenTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("first_seen_time");
+
+                    b.Property<DateTime?>("LastReadRules")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_read_rules");
+
+                    b.Property<IPAddress>("LastSeenAddress")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("last_seen_address");
+
+                    b.Property<byte[]>("LastSeenHWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("last_seen_hwid");
+
+                    b.Property<DateTime>("LastSeenTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_seen_time");
+
+                    b.Property<string>("LastSeenUserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("last_seen_user_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_player");
+
+                    b.HasAlternateKey("UserId")
+                        .HasName("ak_player_user_id");
+
+                    b.HasIndex("LastSeenUserName");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("player", null, t =>
+                        {
+                            t.HasCheckConstraint("LastSeenAddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= last_seen_address");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("preference_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdminOOCColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("admin_ooc_color");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("integer")
+                        .HasColumnName("selected_character_slot");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_preference");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("preference", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Age")
+                        .HasColumnType("integer")
+                        .HasColumnName("age");
+
+                    b.Property<string>("Backpack")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("backpack");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("char_name");
+
+                    b.Property<string>("Clothing")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("clothing");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("eye_color");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("facial_hair_color");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("facial_hair_name");
+
+                    b.Property<string>("FlavorText")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flavor_text");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("hair_color");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("hair_name");
+
+                    b.Property<float>("Height")
+                        .HasColumnType("real")
+                        .HasColumnName("height");
+
+                    b.Property<JsonDocument>("Markings")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("markings");
+
+                    b.Property<int>("PreferenceId")
+                        .HasColumnType("integer")
+                        .HasColumnName("preference_id");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("integer")
+                        .HasColumnName("pref_unavailable");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("sex");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("skin_color");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("integer")
+                        .HasColumnName("slot");
+
+                    b.Property<string>("Species")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("species");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile");
+
+                    b.HasIndex("PreferenceId")
+                        .HasDatabaseName("IX_profile_preference_id");
+
+                    b.HasIndex("Slot", "PreferenceId")
+                        .IsUnique();
+
+                    b.ToTable("profile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ServerId")
+                        .HasColumnType("integer")
+                        .HasColumnName("server_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_round");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_round_server_id");
+
+                    b.ToTable("round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server");
+
+                    b.ToTable("server", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_ban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<ValueTuple<IPAddress, int>?>("Address")
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<bool>("AutoDelete")
+                        .HasColumnType("boolean")
+                        .HasColumnName("auto_delete");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<int>("ExemptFlags")
+                        .HasColumnType("integer")
+                        .HasColumnName("exempt_flags");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("server_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanExemption", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<int>("Flags")
+                        .HasColumnType("integer")
+                        .HasColumnName("flags");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_server_ban_exemption");
+
+                    b.ToTable("server_ban_exemption", null, t =>
+                        {
+                            t.HasCheckConstraint("FlagsNotZero", "flags != 0");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_ban_hit_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<int>("ConnectionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("connection_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban_hit");
+
+                    b.HasIndex("BanId")
+                        .HasDatabaseName("IX_server_ban_hit_ban_id");
+
+                    b.HasIndex("ConnectionId")
+                        .HasDatabaseName("IX_server_ban_hit_connection_id");
+
+                    b.ToTable("server_ban_hit", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_role_ban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<ValueTuple<IPAddress, int>?>("Address")
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("role_id");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("server_role_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("role_unban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_role_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("unban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("trait_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.Property<string>("TraitName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trait_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_trait");
+
+                    b.HasIndex("ProfileId", "TraitName")
+                        .IsUnique();
+
+                    b.ToTable("trait", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.UploadedResourceLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("uploaded_resource_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<byte[]>("Data")
+                        .IsRequired()
+                        .HasColumnType("bytea")
+                        .HasColumnName("data");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("date");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("path");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_uploaded_resource_log");
+
+                    b.ToTable("uploaded_resource_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Whitelist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_whitelist");
+
+                    b.ToTable("whitelist", (string)null);
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.Property<int>("PlayersId")
+                        .HasColumnType("integer")
+                        .HasColumnName("players_id");
+
+                    b.Property<int>("RoundsId")
+                        .HasColumnType("integer")
+                        .HasColumnName("rounds_id");
+
+                    b.HasKey("PlayersId", "RoundsId")
+                        .HasName("PK_player_round");
+
+                    b.HasIndex("RoundsId")
+                        .HasDatabaseName("IX_player_round_rounds_id");
+
+                    b.ToTable("player_round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "AdminRank")
+                        .WithMany("Admins")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_admin_rank_admin_rank_id");
+
+                    b.Navigation("AdminRank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Admin", "Admin")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_flag_admin_admin_id");
+
+                    b.Navigation("Admin");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_round_round_id");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogEntity", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminLog", null)
+                        .WithMany("Entities")
+                        .HasForeignKey("AdminLogId", "AdminLogRoundId")
+                        .HasConstraintName("FK_admin_log_entity_admin_log_admin_log_id_admin_log_round_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.AdminLog", "Log")
+                        .WithMany("Players")
+                        .HasForeignKey("LogId", "RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_admin_log_log_id_round_id");
+
+                    b.Navigation("Log");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminNotesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_notes_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminNotesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .HasConstraintName("FK_admin_notes_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminNotesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_notes_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminNotesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_notes_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_notes_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "Rank")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_rank_flag_admin_rank_admin_rank_id");
+
+                    b.Navigation("Rank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_antag_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_job_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Preference", "Preference")
+                        .WithMany("Profiles")
+                        .HasForeignKey("PreferenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_preference_preference_id");
+
+                    b.Navigation("Preference");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("Rounds")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_round_server_server_id");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithMany("BanHits")
+                        .HasForeignKey("BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_server_ban_ban_id");
+
+                    b.HasOne("Content.Server.Database.ConnectionLog", "Connection")
+                        .WithMany("BanHits")
+                        .HasForeignKey("ConnectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_connection_log_connection_id");
+
+                    b.Navigation("Ban");
+
+                    b.Navigation("Connection");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerRoleBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerRoleUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_role_unban_server_role_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_unban_server_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Traits")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_trait_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", null)
+                        .WithMany()
+                        .HasForeignKey("PlayersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_player_players_id");
+
+                    b.HasOne("Content.Server.Database.Round", null)
+                        .WithMany()
+                        .HasForeignKey("RoundsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_round_rounds_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Navigation("Entities");
+
+                    b.Navigation("Players");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Navigation("Admins");
+
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Navigation("BanHits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Navigation("AdminLogs");
+
+                    b.Navigation("AdminNotesCreated");
+
+                    b.Navigation("AdminNotesDeleted");
+
+                    b.Navigation("AdminNotesLastEdited");
+
+                    b.Navigation("AdminNotesReceived");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Navigation("Profiles");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Navigation("Antags");
+
+                    b.Navigation("Jobs");
+
+                    b.Navigation("Traits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Navigation("Rounds");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Navigation("BanHits");
+
+                    b.Navigation("Unban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Navigation("Unban");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/20230711102742_Height.cs b/Content.Server.Database/Migrations/Postgres/20230711102742_Height.cs
new file mode 100644
index 00000000000..8647022a5c4
--- /dev/null
+++ b/Content.Server.Database/Migrations/Postgres/20230711102742_Height.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    /// <inheritdoc />
+    public partial class Height : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<float>(
+                name: "height",
+                table: "profile",
+                type: "REAL",
+                nullable: false,
+                defaultValue: 1f);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "height",
+                table: "profile");
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/20240119204209_CDCharacterRecords.Designer.cs b/Content.Server.Database/Migrations/Postgres/20240119204209_CDCharacterRecords.Designer.cs
new file mode 100644
index 00000000000..f3f2766d9fe
--- /dev/null
+++ b/Content.Server.Database/Migrations/Postgres/20240119204209_CDCharacterRecords.Designer.cs
@@ -0,0 +1,1764 @@
+// <auto-generated />
+using System;
+using System.Net;
+using System.Text.Json;
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    [DbContext(typeof(PostgresServerDbContext))]
+    [Migration("20240119204209_CDCharacterRecords")]
+    partial class CDCharacterRecords
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "7.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<int?>("AdminRankId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text")
+                        .HasColumnName("title");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_admin");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_admin_rank_id");
+
+                    b.ToTable("admin", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_flag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AdminId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("admin_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flag");
+
+                    b.Property<bool>("Negative")
+                        .HasColumnType("boolean")
+                        .HasColumnName("negative");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_flag");
+
+                    b.HasIndex("AdminId")
+                        .HasDatabaseName("IX_admin_flag_admin_id");
+
+                    b.HasIndex("Flag", "AdminId")
+                        .IsUnique();
+
+                    b.ToTable("admin_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Property<int>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Id")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("date");
+
+                    b.Property<short>("Impact")
+                        .HasColumnType("smallint")
+                        .HasColumnName("impact");
+
+                    b.Property<JsonDocument>("Json")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("json");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("message");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer")
+                        .HasColumnName("type");
+
+                    b.HasKey("RoundId", "Id")
+                        .HasName("PK_admin_log");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Message")
+                        .HasAnnotation("Npgsql:TsVectorConfig", "english");
+
+                    NpgsqlIndexBuilderExtensions.HasMethod(b.HasIndex("Message"), "GIN");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_admin_log_type");
+
+                    b.ToTable("admin_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.Property<int>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("LogId")
+                        .HasColumnType("integer")
+                        .HasColumnName("log_id");
+
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.HasKey("RoundId", "LogId", "PlayerUserId")
+                        .HasName("PK_admin_log_player");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_log_player_player_user_id");
+
+                    b.ToTable("admin_log_player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_messages_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("Seen")
+                        .HasColumnType("boolean")
+                        .HasColumnName("seen");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_messages");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_messages_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_messages_round_id");
+
+                    b.ToTable("admin_messages", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_notes_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("Secret")
+                        .HasColumnType("boolean")
+                        .HasColumnName("secret");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_notes");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_notes_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_notes_round_id");
+
+                    b.ToTable("admin_notes", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank");
+
+                    b.ToTable("admin_rank", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_flag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AdminRankId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flag");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank_flag");
+
+                    b.HasIndex("AdminRankId");
+
+                    b.HasIndex("Flag", "AdminRankId")
+                        .IsUnique();
+
+                    b.ToTable("admin_rank_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminWatchlist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_watchlists_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_watchlists");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_watchlists_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_watchlists_round_id");
+
+                    b.ToTable("admin_watchlists", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("antag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("antag_name");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_antag");
+
+                    b.HasIndex("ProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("antag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AssignedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("assigned_user_id_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_assigned_user_id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("assigned_user_id", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("connection_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<IPAddress>("Address")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<byte?>("Denied")
+                        .HasColumnType("smallint")
+                        .HasColumnName("denied");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<int>("ServerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(0)
+                        .HasColumnName("server_id");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("time");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_connection_log");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_connection_log_server_id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("connection_log", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("job_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer")
+                        .HasColumnName("priority");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_job");
+
+                    b.HasIndex("ProfileId");
+
+                    b.HasIndex("ProfileId", "JobName")
+                        .IsUnique();
+
+                    b.HasIndex(new[] { "ProfileId" }, "IX_job_one_high_priority")
+                        .IsUnique()
+                        .HasFilter("priority = 3");
+
+                    b.ToTable("job", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.PlayTime", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("play_time_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("PlayerId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_id");
+
+                    b.Property<TimeSpan>("TimeSpent")
+                        .HasColumnType("interval")
+                        .HasColumnName("time_spent");
+
+                    b.Property<string>("Tracker")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("tracker");
+
+                    b.HasKey("Id")
+                        .HasName("PK_play_time");
+
+                    b.HasIndex("PlayerId", "Tracker")
+                        .IsUnique();
+
+                    b.ToTable("play_time", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("player_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("FirstSeenTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("first_seen_time");
+
+                    b.Property<DateTime?>("LastReadRules")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_read_rules");
+
+                    b.Property<IPAddress>("LastSeenAddress")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("last_seen_address");
+
+                    b.Property<byte[]>("LastSeenHWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("last_seen_hwid");
+
+                    b.Property<DateTime>("LastSeenTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_seen_time");
+
+                    b.Property<string>("LastSeenUserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("last_seen_user_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_player");
+
+                    b.HasAlternateKey("UserId")
+                        .HasName("ak_player_user_id");
+
+                    b.HasIndex("LastSeenUserName");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("player", null, t =>
+                        {
+                            t.HasCheckConstraint("LastSeenAddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= last_seen_address");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("preference_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdminOOCColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("admin_ooc_color");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("integer")
+                        .HasColumnName("selected_character_slot");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_preference");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("preference", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Age")
+                        .HasColumnType("integer")
+                        .HasColumnName("age");
+
+                    b.Property<string>("Backpack")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("backpack");
+
+                    b.Property<JsonDocument>("CDCharacterRecords")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("cd_character_records");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("char_name");
+
+                    b.Property<string>("Clothing")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("clothing");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("eye_color");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("facial_hair_color");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("facial_hair_name");
+
+                    b.Property<string>("FlavorText")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flavor_text");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("hair_color");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("hair_name");
+
+                    b.Property<float>("Height")
+                        .HasColumnType("real")
+                        .HasColumnName("height");
+
+                    b.Property<JsonDocument>("Markings")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("markings");
+
+                    b.Property<int>("PreferenceId")
+                        .HasColumnType("integer")
+                        .HasColumnName("preference_id");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("integer")
+                        .HasColumnName("pref_unavailable");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("sex");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("skin_color");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("integer")
+                        .HasColumnName("slot");
+
+                    b.Property<string>("Species")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("species");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile");
+
+                    b.HasIndex("PreferenceId")
+                        .HasDatabaseName("IX_profile_preference_id");
+
+                    b.HasIndex("Slot", "PreferenceId")
+                        .IsUnique();
+
+                    b.ToTable("profile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ServerId")
+                        .HasColumnType("integer")
+                        .HasColumnName("server_id");
+
+                    b.Property<DateTime>("StartDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValue(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified))
+                        .HasColumnName("start_date");
+
+                    b.HasKey("Id")
+                        .HasName("PK_round");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_round_server_id");
+
+                    b.HasIndex("StartDate");
+
+                    b.ToTable("round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server");
+
+                    b.ToTable("server", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_ban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<ValueTuple<IPAddress, int>?>("Address")
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<bool>("AutoDelete")
+                        .HasColumnType("boolean")
+                        .HasColumnName("auto_delete");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<int>("ExemptFlags")
+                        .HasColumnType("integer")
+                        .HasColumnName("exempt_flags");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("boolean")
+                        .HasColumnName("hidden");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("BanningAdmin");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_server_ban_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_server_ban_round_id");
+
+                    b.ToTable("server_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR player_user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanExemption", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<int>("Flags")
+                        .HasColumnType("integer")
+                        .HasColumnName("flags");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_server_ban_exemption");
+
+                    b.ToTable("server_ban_exemption", null, t =>
+                        {
+                            t.HasCheckConstraint("FlagsNotZero", "flags != 0");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_ban_hit_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<int>("ConnectionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("connection_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban_hit");
+
+                    b.HasIndex("BanId")
+                        .HasDatabaseName("IX_server_ban_hit_ban_id");
+
+                    b.HasIndex("ConnectionId")
+                        .HasDatabaseName("IX_server_ban_hit_connection_id");
+
+                    b.ToTable("server_ban_hit", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_role_ban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<ValueTuple<IPAddress, int>?>("Address")
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("boolean")
+                        .HasColumnName("hidden");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("interval")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("role_id");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("BanningAdmin");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_server_role_ban_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_server_role_ban_round_id");
+
+                    b.ToTable("server_role_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR player_user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("role_unban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_role_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("unban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("trait_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.Property<string>("TraitName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trait_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_trait");
+
+                    b.HasIndex("ProfileId", "TraitName")
+                        .IsUnique();
+
+                    b.ToTable("trait", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.UploadedResourceLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("uploaded_resource_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<byte[]>("Data")
+                        .IsRequired()
+                        .HasColumnType("bytea")
+                        .HasColumnName("data");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("date");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("path");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_uploaded_resource_log");
+
+                    b.ToTable("uploaded_resource_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Whitelist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_whitelist");
+
+                    b.ToTable("whitelist", (string)null);
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.Property<int>("PlayersId")
+                        .HasColumnType("integer")
+                        .HasColumnName("players_id");
+
+                    b.Property<int>("RoundsId")
+                        .HasColumnType("integer")
+                        .HasColumnName("rounds_id");
+
+                    b.HasKey("PlayersId", "RoundsId")
+                        .HasName("PK_player_round");
+
+                    b.HasIndex("RoundsId")
+                        .HasDatabaseName("IX_player_round_rounds_id");
+
+                    b.ToTable("player_round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "AdminRank")
+                        .WithMany("Admins")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_admin_rank_admin_rank_id");
+
+                    b.Navigation("AdminRank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Admin", "Admin")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_flag_admin_admin_id");
+
+                    b.Navigation("Admin");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_round_round_id");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.AdminLog", "Log")
+                        .WithMany("Players")
+                        .HasForeignKey("RoundId", "LogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_admin_log_round_id_log_id");
+
+                    b.Navigation("Log");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminMessage", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminMessagesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminMessagesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminMessagesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminMessagesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_messages_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_messages_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminNotesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminNotesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminNotesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminNotesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_notes_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_notes_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "Rank")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_rank_flag_admin_rank_admin_rank_id");
+
+                    b.Navigation("Rank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminWatchlist", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminWatchlistsCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminWatchlistsDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminWatchlistsLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminWatchlistsReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_watchlists_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_watchlists_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_antag_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("ConnectionLogs")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired()
+                        .HasConstraintName("FK_connection_log_server_server_id");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_job_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Preference", "Preference")
+                        .WithMany("Profiles")
+                        .HasForeignKey("PreferenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_preference_preference_id");
+
+                    b.Navigation("Preference");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("Rounds")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_round_server_server_id");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminServerBansCreated")
+                        .HasForeignKey("BanningAdmin")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_ban_player_banning_admin");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminServerBansLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_ban_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_server_ban_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithMany("BanHits")
+                        .HasForeignKey("BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_server_ban_ban_id");
+
+                    b.HasOne("Content.Server.Database.ConnectionLog", "Connection")
+                        .WithMany("BanHits")
+                        .HasForeignKey("ConnectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_connection_log_connection_id");
+
+                    b.Navigation("Ban");
+
+                    b.Navigation("Connection");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminServerRoleBansCreated")
+                        .HasForeignKey("BanningAdmin")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_role_ban_player_banning_admin");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminServerRoleBansLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_role_ban_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_server_role_ban_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerRoleBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerRoleUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_role_unban_server_role_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_unban_server_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Traits")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_trait_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", null)
+                        .WithMany()
+                        .HasForeignKey("PlayersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_player_players_id");
+
+                    b.HasOne("Content.Server.Database.Round", null)
+                        .WithMany()
+                        .HasForeignKey("RoundsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_round_rounds_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Navigation("Players");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Navigation("Admins");
+
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Navigation("BanHits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Navigation("AdminLogs");
+
+                    b.Navigation("AdminMessagesCreated");
+
+                    b.Navigation("AdminMessagesDeleted");
+
+                    b.Navigation("AdminMessagesLastEdited");
+
+                    b.Navigation("AdminMessagesReceived");
+
+                    b.Navigation("AdminNotesCreated");
+
+                    b.Navigation("AdminNotesDeleted");
+
+                    b.Navigation("AdminNotesLastEdited");
+
+                    b.Navigation("AdminNotesReceived");
+
+                    b.Navigation("AdminServerBansCreated");
+
+                    b.Navigation("AdminServerBansLastEdited");
+
+                    b.Navigation("AdminServerRoleBansCreated");
+
+                    b.Navigation("AdminServerRoleBansLastEdited");
+
+                    b.Navigation("AdminWatchlistsCreated");
+
+                    b.Navigation("AdminWatchlistsDeleted");
+
+                    b.Navigation("AdminWatchlistsLastEdited");
+
+                    b.Navigation("AdminWatchlistsReceived");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Navigation("Profiles");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Navigation("Antags");
+
+                    b.Navigation("Jobs");
+
+                    b.Navigation("Traits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Navigation("ConnectionLogs");
+
+                    b.Navigation("Rounds");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Navigation("BanHits");
+
+                    b.Navigation("Unban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Navigation("Unban");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/20240119204209_CDCharacterRecords.cs b/Content.Server.Database/Migrations/Postgres/20240119204209_CDCharacterRecords.cs
new file mode 100644
index 00000000000..e43cd948079
--- /dev/null
+++ b/Content.Server.Database/Migrations/Postgres/20240119204209_CDCharacterRecords.cs
@@ -0,0 +1,29 @@
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    /// <inheritdoc />
+    public partial class CDCharacterRecords : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<JsonDocument>(
+                name: "cd_character_records",
+                table: "profile",
+                type: "jsonb",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "cd_character_records",
+                table: "profile");
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs b/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
index ae40e1228e0..739d1cb78f0 100644
--- a/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
+++ b/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
@@ -733,6 +733,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("text")
                         .HasColumnName("backpack");
 
+                    b.Property<JsonDocument>("CDCharacterRecords")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("cd_character_records");
+
                     b.Property<string>("CharacterName")
                         .IsRequired()
                         .HasColumnType("text")
@@ -778,6 +782,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("text")
                         .HasColumnName("hair_name");
 
+                    b.Property<float>("Height")
+                        .HasColumnType("real")
+                        .HasColumnName("height");
+
                     b.Property<JsonDocument>("Markings")
                         .HasColumnType("jsonb")
                         .HasColumnName("markings");
diff --git a/Content.Server.Database/Migrations/Sqlite/20230711102028_Height.Designer.cs b/Content.Server.Database/Migrations/Sqlite/20230711102028_Height.Designer.cs
new file mode 100644
index 00000000000..32e0d4e83c3
--- /dev/null
+++ b/Content.Server.Database/Migrations/Sqlite/20230711102028_Height.Designer.cs
@@ -0,0 +1,1300 @@
+// <auto-generated />
+using System;
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    [DbContext(typeof(SqliteServerDbContext))]
+    [Migration("20230711102028_Height")]
+    partial class Height
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "7.0.4");
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<int?>("AdminRankId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_admin");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_admin_rank_id");
+
+                    b.ToTable("admin", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_flag_id");
+
+                    b.Property<Guid>("AdminId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("admin_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flag");
+
+                    b.Property<bool>("Negative")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("negative");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_flag");
+
+                    b.HasIndex("AdminId")
+                        .HasDatabaseName("IX_admin_flag_admin_id");
+
+                    b.HasIndex("Flag", "AdminId")
+                        .IsUnique();
+
+                    b.ToTable("admin_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<int>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("date");
+
+                    b.Property<sbyte>("Impact")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("impact");
+
+                    b.Property<string>("Json")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("json");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id", "RoundId")
+                        .HasName("PK_admin_log");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_log_round_id");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_admin_log_type");
+
+                    b.ToTable("admin_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogEntity", b =>
+                {
+                    b.Property<int>("Uid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("uid");
+
+                    b.Property<int?>("AdminLogId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<int?>("AdminLogRoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_log_round_id");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Uid")
+                        .HasName("PK_admin_log_entity");
+
+                    b.HasIndex("AdminLogId", "AdminLogRoundId")
+                        .HasDatabaseName("IX_admin_log_entity_admin_log_id_admin_log_round_id");
+
+                    b.ToTable("admin_log_entity", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<int>("LogId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("log_id");
+
+                    b.Property<int>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("PlayerUserId", "LogId", "RoundId")
+                        .HasName("PK_admin_log_player");
+
+                    b.HasIndex("LogId", "RoundId");
+
+                    b.ToTable("admin_log_player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_notes_id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid>("CreatedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime>("LastEditedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("ShownToPlayer")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("shown_to_player");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_notes");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_notes_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_notes_round_id");
+
+                    b.ToTable("admin_notes", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank");
+
+                    b.ToTable("admin_rank", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_flag_id");
+
+                    b.Property<int>("AdminRankId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flag");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank_flag");
+
+                    b.HasIndex("AdminRankId");
+
+                    b.HasIndex("Flag", "AdminRankId")
+                        .IsUnique();
+
+                    b.ToTable("admin_rank_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("antag_id");
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("antag_name");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_antag");
+
+                    b.HasIndex("ProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("antag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AssignedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("assigned_user_id_id");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_assigned_user_id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("assigned_user_id", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("connection_log_id");
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<byte?>("Denied")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("denied");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_connection_log");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("connection_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("job_id");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("priority");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_job");
+
+                    b.HasIndex("ProfileId");
+
+                    b.HasIndex("ProfileId", "JobName")
+                        .IsUnique();
+
+                    b.HasIndex(new[] { "ProfileId" }, "IX_job_one_high_priority")
+                        .IsUnique()
+                        .HasFilter("priority = 3");
+
+                    b.ToTable("job", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.PlayTime", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("play_time_id");
+
+                    b.Property<Guid>("PlayerId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_id");
+
+                    b.Property<TimeSpan>("TimeSpent")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_spent");
+
+                    b.Property<string>("Tracker")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("tracker");
+
+                    b.HasKey("Id")
+                        .HasName("PK_play_time");
+
+                    b.HasIndex("PlayerId", "Tracker")
+                        .IsUnique();
+
+                    b.ToTable("play_time", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("player_id");
+
+                    b.Property<DateTime>("FirstSeenTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("first_seen_time");
+
+                    b.Property<DateTime?>("LastReadRules")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_read_rules");
+
+                    b.Property<string>("LastSeenAddress")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_address");
+
+                    b.Property<byte[]>("LastSeenHWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("last_seen_hwid");
+
+                    b.Property<DateTime>("LastSeenTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_time");
+
+                    b.Property<string>("LastSeenUserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_user_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_player");
+
+                    b.HasAlternateKey("UserId")
+                        .HasName("ak_player_user_id");
+
+                    b.HasIndex("LastSeenUserName");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("preference_id");
+
+                    b.Property<string>("AdminOOCColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("admin_ooc_color");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("selected_character_slot");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_preference");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("preference", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.Property<int>("Age")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("age");
+
+                    b.Property<string>("Backpack")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("backpack");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("char_name");
+
+                    b.Property<string>("Clothing")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("clothing");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("eye_color");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("facial_hair_color");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("facial_hair_name");
+
+                    b.Property<string>("FlavorText")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flavor_text");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("hair_color");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("hair_name");
+
+                    b.Property<float>("Height")
+                        .HasColumnType("REAL")
+                        .HasColumnName("height");
+
+                    b.Property<byte[]>("Markings")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("markings");
+
+                    b.Property<int>("PreferenceId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("preference_id");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("pref_unavailable");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("sex");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("skin_color");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("slot");
+
+                    b.Property<string>("Species")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("species");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile");
+
+                    b.HasIndex("PreferenceId")
+                        .HasDatabaseName("IX_profile_preference_id");
+
+                    b.HasIndex("Slot", "PreferenceId")
+                        .IsUnique();
+
+                    b.ToTable("profile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("ServerId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_round");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_round_server_id");
+
+                    b.ToTable("round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_id");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server");
+
+                    b.ToTable("server", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_ban_id");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<bool>("AutoDelete")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("auto_delete");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<int>("ExemptFlags")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exempt_flags");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("server_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanExemption", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<int>("Flags")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("flags");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_server_ban_exemption");
+
+                    b.ToTable("server_ban_exemption", null, t =>
+                        {
+                            t.HasCheckConstraint("FlagsNotZero", "flags != 0");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_ban_hit_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<int>("ConnectionId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("connection_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban_hit");
+
+                    b.HasIndex("BanId")
+                        .HasDatabaseName("IX_server_ban_hit_ban_id");
+
+                    b.HasIndex("ConnectionId")
+                        .HasDatabaseName("IX_server_ban_hit_connection_id");
+
+                    b.ToTable("server_ban_hit", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_role_ban_id");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("role_id");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("server_role_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("role_unban_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_role_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("unban_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("trait_id");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.Property<string>("TraitName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("trait_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_trait");
+
+                    b.HasIndex("ProfileId", "TraitName")
+                        .IsUnique();
+
+                    b.ToTable("trait", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.UploadedResourceLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("uploaded_resource_log_id");
+
+                    b.Property<byte[]>("Data")
+                        .IsRequired()
+                        .HasColumnType("BLOB")
+                        .HasColumnName("data");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("date");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_uploaded_resource_log");
+
+                    b.ToTable("uploaded_resource_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Whitelist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_whitelist");
+
+                    b.ToTable("whitelist", (string)null);
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.Property<int>("PlayersId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("players_id");
+
+                    b.Property<int>("RoundsId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("rounds_id");
+
+                    b.HasKey("PlayersId", "RoundsId")
+                        .HasName("PK_player_round");
+
+                    b.HasIndex("RoundsId")
+                        .HasDatabaseName("IX_player_round_rounds_id");
+
+                    b.ToTable("player_round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "AdminRank")
+                        .WithMany("Admins")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_admin_rank_admin_rank_id");
+
+                    b.Navigation("AdminRank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Admin", "Admin")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_flag_admin_admin_id");
+
+                    b.Navigation("Admin");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_round_round_id");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogEntity", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminLog", null)
+                        .WithMany("Entities")
+                        .HasForeignKey("AdminLogId", "AdminLogRoundId")
+                        .HasConstraintName("FK_admin_log_entity_admin_log_admin_log_id_admin_log_round_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.AdminLog", "Log")
+                        .WithMany("Players")
+                        .HasForeignKey("LogId", "RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_admin_log_log_id_round_id");
+
+                    b.Navigation("Log");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminNotesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_notes_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminNotesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .HasConstraintName("FK_admin_notes_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminNotesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_notes_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminNotesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_notes_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_notes_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "Rank")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_rank_flag_admin_rank_admin_rank_id");
+
+                    b.Navigation("Rank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_antag_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_job_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Preference", "Preference")
+                        .WithMany("Profiles")
+                        .HasForeignKey("PreferenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_preference_preference_id");
+
+                    b.Navigation("Preference");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("Rounds")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_round_server_server_id");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithMany("BanHits")
+                        .HasForeignKey("BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_server_ban_ban_id");
+
+                    b.HasOne("Content.Server.Database.ConnectionLog", "Connection")
+                        .WithMany("BanHits")
+                        .HasForeignKey("ConnectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_connection_log_connection_id");
+
+                    b.Navigation("Ban");
+
+                    b.Navigation("Connection");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerRoleBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerRoleUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_role_unban_server_role_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_unban_server_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Traits")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_trait_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", null)
+                        .WithMany()
+                        .HasForeignKey("PlayersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_player_players_id");
+
+                    b.HasOne("Content.Server.Database.Round", null)
+                        .WithMany()
+                        .HasForeignKey("RoundsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_round_rounds_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Navigation("Entities");
+
+                    b.Navigation("Players");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Navigation("Admins");
+
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Navigation("BanHits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Navigation("AdminLogs");
+
+                    b.Navigation("AdminNotesCreated");
+
+                    b.Navigation("AdminNotesDeleted");
+
+                    b.Navigation("AdminNotesLastEdited");
+
+                    b.Navigation("AdminNotesReceived");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Navigation("Profiles");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Navigation("Antags");
+
+                    b.Navigation("Jobs");
+
+                    b.Navigation("Traits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Navigation("Rounds");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Navigation("BanHits");
+
+                    b.Navigation("Unban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Navigation("Unban");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Sqlite/20230711102028_Height.cs b/Content.Server.Database/Migrations/Sqlite/20230711102028_Height.cs
new file mode 100644
index 00000000000..39d748446b4
--- /dev/null
+++ b/Content.Server.Database/Migrations/Sqlite/20230711102028_Height.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    /// <inheritdoc />
+    public partial class Height : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<float>(
+                name: "height",
+                table: "profile",
+                type: "REAL",
+                nullable: false,
+                defaultValue: 1f);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "height",
+                table: "profile");
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Sqlite/20240119204158_CDCharacterRecords.Designer.cs b/Content.Server.Database/Migrations/Sqlite/20240119204158_CDCharacterRecords.Designer.cs
new file mode 100644
index 00000000000..b904d5624a7
--- /dev/null
+++ b/Content.Server.Database/Migrations/Sqlite/20240119204158_CDCharacterRecords.Designer.cs
@@ -0,0 +1,1696 @@
+// <auto-generated />
+using System;
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    [DbContext(typeof(SqliteServerDbContext))]
+    [Migration("20240119204158_CDCharacterRecords")]
+    partial class CDCharacterRecords
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "7.0.4");
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<int?>("AdminRankId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_admin");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_admin_rank_id");
+
+                    b.ToTable("admin", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_flag_id");
+
+                    b.Property<Guid>("AdminId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("admin_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flag");
+
+                    b.Property<bool>("Negative")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("negative");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_flag");
+
+                    b.HasIndex("AdminId")
+                        .HasDatabaseName("IX_admin_flag_admin_id");
+
+                    b.HasIndex("Flag", "AdminId")
+                        .IsUnique();
+
+                    b.ToTable("admin_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Property<int>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("date");
+
+                    b.Property<sbyte>("Impact")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("impact");
+
+                    b.Property<string>("Json")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("json");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("type");
+
+                    b.HasKey("RoundId", "Id")
+                        .HasName("PK_admin_log");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_admin_log_type");
+
+                    b.ToTable("admin_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.Property<int>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("LogId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("log_id");
+
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.HasKey("RoundId", "LogId", "PlayerUserId")
+                        .HasName("PK_admin_log_player");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_log_player_player_user_id");
+
+                    b.ToTable("admin_log_player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_messages_id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("Seen")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("seen");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_messages");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_messages_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_messages_round_id");
+
+                    b.ToTable("admin_messages", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_notes_id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<bool>("Secret")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("secret");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_notes");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_notes_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_notes_round_id");
+
+                    b.ToTable("admin_notes", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank");
+
+                    b.ToTable("admin_rank", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_flag_id");
+
+                    b.Property<int>("AdminRankId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flag");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank_flag");
+
+                    b.HasIndex("AdminRankId");
+
+                    b.HasIndex("Flag", "AdminRankId")
+                        .IsUnique();
+
+                    b.ToTable("admin_rank_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminWatchlist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_watchlists_id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid?>("CreatedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by_id");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Guid?>("DeletedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("deleted_by_id");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_watchlists");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("DeletedById");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_admin_watchlists_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_watchlists_round_id");
+
+                    b.ToTable("admin_watchlists", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("antag_id");
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("antag_name");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_antag");
+
+                    b.HasIndex("ProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("antag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AssignedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("assigned_user_id_id");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_assigned_user_id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("assigned_user_id", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("connection_log_id");
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<byte?>("Denied")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("denied");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<int>("ServerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("server_id");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_connection_log");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_connection_log_server_id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("connection_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("job_id");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("priority");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_job");
+
+                    b.HasIndex("ProfileId");
+
+                    b.HasIndex("ProfileId", "JobName")
+                        .IsUnique();
+
+                    b.HasIndex(new[] { "ProfileId" }, "IX_job_one_high_priority")
+                        .IsUnique()
+                        .HasFilter("priority = 3");
+
+                    b.ToTable("job", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.PlayTime", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("play_time_id");
+
+                    b.Property<Guid>("PlayerId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_id");
+
+                    b.Property<TimeSpan>("TimeSpent")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_spent");
+
+                    b.Property<string>("Tracker")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("tracker");
+
+                    b.HasKey("Id")
+                        .HasName("PK_play_time");
+
+                    b.HasIndex("PlayerId", "Tracker")
+                        .IsUnique();
+
+                    b.ToTable("play_time", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("player_id");
+
+                    b.Property<DateTime>("FirstSeenTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("first_seen_time");
+
+                    b.Property<DateTime?>("LastReadRules")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_read_rules");
+
+                    b.Property<string>("LastSeenAddress")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_address");
+
+                    b.Property<byte[]>("LastSeenHWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("last_seen_hwid");
+
+                    b.Property<DateTime>("LastSeenTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_time");
+
+                    b.Property<string>("LastSeenUserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_user_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_player");
+
+                    b.HasAlternateKey("UserId")
+                        .HasName("ak_player_user_id");
+
+                    b.HasIndex("LastSeenUserName");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("preference_id");
+
+                    b.Property<string>("AdminOOCColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("admin_ooc_color");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("selected_character_slot");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_preference");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("preference", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.Property<int>("Age")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("age");
+
+                    b.Property<string>("Backpack")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("backpack");
+
+                    b.Property<byte[]>("CDCharacterRecords")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("cd_character_records");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("char_name");
+
+                    b.Property<string>("Clothing")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("clothing");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("eye_color");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("facial_hair_color");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("facial_hair_name");
+
+                    b.Property<string>("FlavorText")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flavor_text");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("hair_color");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("hair_name");
+
+                    b.Property<float>("Height")
+                        .HasColumnType("REAL")
+                        .HasColumnName("height");
+
+                    b.Property<byte[]>("Markings")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("markings");
+
+                    b.Property<int>("PreferenceId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("preference_id");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("pref_unavailable");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("sex");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("skin_color");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("slot");
+
+                    b.Property<string>("Species")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("species");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile");
+
+                    b.HasIndex("PreferenceId")
+                        .HasDatabaseName("IX_profile_preference_id");
+
+                    b.HasIndex("Slot", "PreferenceId")
+                        .IsUnique();
+
+                    b.ToTable("profile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("ServerId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_id");
+
+                    b.Property<DateTime>("StartDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified))
+                        .HasColumnName("start_date");
+
+                    b.HasKey("Id")
+                        .HasName("PK_round");
+
+                    b.HasIndex("ServerId")
+                        .HasDatabaseName("IX_round_server_id");
+
+                    b.HasIndex("StartDate");
+
+                    b.ToTable("round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_id");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server");
+
+                    b.ToTable("server", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_ban_id");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<bool>("AutoDelete")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("auto_delete");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<int>("ExemptFlags")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exempt_flags");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("hidden");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("BanningAdmin");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_server_ban_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_server_ban_round_id");
+
+                    b.ToTable("server_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR player_user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanExemption", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<int>("Flags")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("flags");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_server_ban_exemption");
+
+                    b.ToTable("server_ban_exemption", null, t =>
+                        {
+                            t.HasCheckConstraint("FlagsNotZero", "flags != 0");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_ban_hit_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<int>("ConnectionId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("connection_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban_hit");
+
+                    b.HasIndex("BanId")
+                        .HasDatabaseName("IX_server_ban_hit_ban_id");
+
+                    b.HasIndex("ConnectionId")
+                        .HasDatabaseName("IX_server_ban_hit_connection_id");
+
+                    b.ToTable("server_ban_hit", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_role_ban_id");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("hidden");
+
+                    b.Property<DateTime?>("LastEditedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_at");
+
+                    b.Property<Guid?>("LastEditedById")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_edited_by_id");
+
+                    b.Property<Guid?>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<TimeSpan>("PlaytimeAtNote")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("playtime_at_note");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("role_id");
+
+                    b.Property<int?>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("severity");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("BanningAdmin");
+
+                    b.HasIndex("LastEditedById");
+
+                    b.HasIndex("PlayerUserId")
+                        .HasDatabaseName("IX_server_role_ban_player_user_id");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_server_role_ban_round_id");
+
+                    b.ToTable("server_role_ban", null, t =>
+                        {
+                            t.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR player_user_id IS NOT NULL OR hwid IS NOT NULL");
+                        });
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("role_unban_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_role_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("unban_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("trait_id");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.Property<string>("TraitName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("trait_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_trait");
+
+                    b.HasIndex("ProfileId", "TraitName")
+                        .IsUnique();
+
+                    b.ToTable("trait", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.UploadedResourceLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("uploaded_resource_log_id");
+
+                    b.Property<byte[]>("Data")
+                        .IsRequired()
+                        .HasColumnType("BLOB")
+                        .HasColumnName("data");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("date");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_uploaded_resource_log");
+
+                    b.ToTable("uploaded_resource_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Whitelist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_whitelist");
+
+                    b.ToTable("whitelist", (string)null);
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.Property<int>("PlayersId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("players_id");
+
+                    b.Property<int>("RoundsId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("rounds_id");
+
+                    b.HasKey("PlayersId", "RoundsId")
+                        .HasName("PK_player_round");
+
+                    b.HasIndex("RoundsId")
+                        .HasDatabaseName("IX_player_round_rounds_id");
+
+                    b.ToTable("player_round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "AdminRank")
+                        .WithMany("Admins")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_admin_rank_admin_rank_id");
+
+                    b.Navigation("AdminRank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Admin", "Admin")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_flag_admin_admin_id");
+
+                    b.Navigation("Admin");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_round_round_id");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.AdminLog", "Log")
+                        .WithMany("Players")
+                        .HasForeignKey("RoundId", "LogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_admin_log_round_id_log_id");
+
+                    b.Navigation("Log");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminMessage", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminMessagesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminMessagesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminMessagesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_messages_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminMessagesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_messages_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_messages_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminNote", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminNotesCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminNotesDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminNotesLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_notes_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminNotesReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_notes_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_notes_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "Rank")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_rank_flag_admin_rank_admin_rank_id");
+
+                    b.Navigation("Rank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminWatchlist", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminWatchlistsCreated")
+                        .HasForeignKey("CreatedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_created_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "DeletedBy")
+                        .WithMany("AdminWatchlistsDeleted")
+                        .HasForeignKey("DeletedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_deleted_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminWatchlistsLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_watchlists_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminWatchlistsReceived")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .HasConstraintName("FK_admin_watchlists_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_admin_watchlists_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("DeletedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Player");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_antag_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("ConnectionLogs")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired()
+                        .HasConstraintName("FK_connection_log_server_server_id");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_job_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Preference", "Preference")
+                        .WithMany("Profiles")
+                        .HasForeignKey("PreferenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_preference_preference_id");
+
+                    b.Navigation("Preference");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.HasOne("Content.Server.Database.Server", "Server")
+                        .WithMany("Rounds")
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_round_server_server_id");
+
+                    b.Navigation("Server");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminServerBansCreated")
+                        .HasForeignKey("BanningAdmin")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_ban_player_banning_admin");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminServerBansLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_ban_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_server_ban_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithMany("BanHits")
+                        .HasForeignKey("BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_server_ban_ban_id");
+
+                    b.HasOne("Content.Server.Database.ConnectionLog", "Connection")
+                        .WithMany("BanHits")
+                        .HasForeignKey("ConnectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_connection_log_connection_id");
+
+                    b.Navigation("Ban");
+
+                    b.Navigation("Connection");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "CreatedBy")
+                        .WithMany("AdminServerRoleBansCreated")
+                        .HasForeignKey("BanningAdmin")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_role_ban_player_banning_admin");
+
+                    b.HasOne("Content.Server.Database.Player", "LastEditedBy")
+                        .WithMany("AdminServerRoleBansLastEdited")
+                        .HasForeignKey("LastEditedById")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_server_role_ban_player_last_edited_by_id");
+
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany()
+                        .HasForeignKey("RoundId")
+                        .HasConstraintName("FK_server_role_ban_round_round_id");
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("LastEditedBy");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerRoleBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerRoleUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_role_unban_server_role_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_unban_server_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Trait", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Traits")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_trait_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", null)
+                        .WithMany()
+                        .HasForeignKey("PlayersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_player_players_id");
+
+                    b.HasOne("Content.Server.Database.Round", null)
+                        .WithMany()
+                        .HasForeignKey("RoundsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_round_rounds_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Navigation("Players");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Navigation("Admins");
+
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Navigation("BanHits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Navigation("AdminLogs");
+
+                    b.Navigation("AdminMessagesCreated");
+
+                    b.Navigation("AdminMessagesDeleted");
+
+                    b.Navigation("AdminMessagesLastEdited");
+
+                    b.Navigation("AdminMessagesReceived");
+
+                    b.Navigation("AdminNotesCreated");
+
+                    b.Navigation("AdminNotesDeleted");
+
+                    b.Navigation("AdminNotesLastEdited");
+
+                    b.Navigation("AdminNotesReceived");
+
+                    b.Navigation("AdminServerBansCreated");
+
+                    b.Navigation("AdminServerBansLastEdited");
+
+                    b.Navigation("AdminServerRoleBansCreated");
+
+                    b.Navigation("AdminServerRoleBansLastEdited");
+
+                    b.Navigation("AdminWatchlistsCreated");
+
+                    b.Navigation("AdminWatchlistsDeleted");
+
+                    b.Navigation("AdminWatchlistsLastEdited");
+
+                    b.Navigation("AdminWatchlistsReceived");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Navigation("Profiles");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Navigation("Antags");
+
+                    b.Navigation("Jobs");
+
+                    b.Navigation("Traits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Server", b =>
+                {
+                    b.Navigation("ConnectionLogs");
+
+                    b.Navigation("Rounds");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Navigation("BanHits");
+
+                    b.Navigation("Unban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Navigation("Unban");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Sqlite/20240119204158_CDCharacterRecords.cs b/Content.Server.Database/Migrations/Sqlite/20240119204158_CDCharacterRecords.cs
new file mode 100644
index 00000000000..930d14ce358
--- /dev/null
+++ b/Content.Server.Database/Migrations/Sqlite/20240119204158_CDCharacterRecords.cs
@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    /// <inheritdoc />
+    public partial class CDCharacterRecords : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<byte[]>(
+                name: "cd_character_records",
+                table: "profile",
+                type: "jsonb",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "cd_character_records",
+                table: "profile");
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs b/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
index c9a36ebc5ed..283510d68e9 100644
--- a/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
+++ b/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
@@ -686,6 +686,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("TEXT")
                         .HasColumnName("backpack");
 
+                    b.Property<byte[]>("CDCharacterRecords")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("cd_character_records");
+
                     b.Property<string>("CharacterName")
                         .IsRequired()
                         .HasColumnType("TEXT")
@@ -731,6 +735,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("TEXT")
                         .HasColumnName("hair_name");
 
+                    b.Property<float>("Height")
+                        .HasColumnType("REAL")
+                        .HasColumnName("height");
+
                     b.Property<byte[]>("Markings")
                         .HasColumnType("jsonb")
                         .HasColumnName("markings");
diff --git a/Content.Server.Database/Model.cs b/Content.Server.Database/Model.cs
index f9ec7811f5d..d58dfd7750c 100644
--- a/Content.Server.Database/Model.cs
+++ b/Content.Server.Database/Model.cs
@@ -329,6 +329,7 @@ public class Profile
         public string Sex { get; set; } = null!;
         public string Gender { get; set; } = null!;
         public string Species { get; set; } = null!;
+        public float Height { get; set; } = 1f;
         [Column(TypeName = "jsonb")] public JsonDocument? Markings { get; set; } = null!;
         public string HairName { get; set; } = null!;
         public string HairColor { get; set; } = null!;
@@ -345,6 +346,10 @@ public class Profile
 
         [Column("pref_unavailable")] public DbPreferenceUnavailableMode PreferenceUnavailable { get; set; }
 
+        // CD: Store character records
+        [Column("cd_character_records", TypeName = "jsonb")]
+        public JsonDocument? CDCharacterRecords { get; set; }
+
         public int PreferenceId { get; set; }
         public Preference Preference { get; set; } = null!;
     }
diff --git a/Content.Server.Database/ModelSqlite.cs b/Content.Server.Database/ModelSqlite.cs
index 392a7c0aae7..f27065bdc78 100644
--- a/Content.Server.Database/ModelSqlite.cs
+++ b/Content.Server.Database/ModelSqlite.cs
@@ -81,6 +81,11 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             modelBuilder.Entity<Profile>()
                 .Property(log => log.Markings)
                 .HasConversion(jsonByteArrayConverter);
+
+            // CD: Store records on profile
+            modelBuilder.Entity<Profile>()
+                .Property(log => log.CDCharacterRecords)
+                .HasConversion(jsonByteArrayConverter);
         }
 
         public override int CountAdminLogs()
diff --git a/Content.Server/Administration/Systems/AdminSystem.cs b/Content.Server/Administration/Systems/AdminSystem.cs
index 53eabb1a481..43b2783b526 100644
--- a/Content.Server/Administration/Systems/AdminSystem.cs
+++ b/Content.Server/Administration/Systems/AdminSystem.cs
@@ -32,6 +32,9 @@
 using Robust.Shared.Network;
 using Robust.Shared.Player;
 
+// CD: imports
+using Content.Server._CD.Records;
+
 namespace Content.Server.Administration.Systems
 {
     public sealed class AdminSystem : EntitySystem
@@ -53,6 +56,9 @@ public sealed class AdminSystem : EntitySystem
         [Dependency] private readonly StationRecordsSystem _stationRecords = default!;
         [Dependency] private readonly TransformSystem _transform = default!;
 
+        // CD: for erasing records on erase ban
+        [Dependency] private readonly CharacterRecordsSystem _cdRecords = default!;
+
         private readonly Dictionary<NetUserId, PlayerInfo> _playerList = new();
 
         /// <summary>
@@ -376,6 +382,9 @@ keyStorage.Key is { } key &&
                         _hands.TryDrop(entity.Value, hand, checkActionBlocker: false, doDropInteraction: false, handsComp: hands);
                     }
                 }
+
+                // CD: Erase Character Records on ban
+                _cdRecords.DeleteAllRecords(entity.Value);
             }
 
             _minds.WipeMind(player);
diff --git a/Content.Server/CriminalRecords/Systems/CriminalRecordsConsoleSystem.cs b/Content.Server/CriminalRecords/Systems/CriminalRecordsConsoleSystem.cs
index 4290726cc40..79ad89f78c3 100644
--- a/Content.Server/CriminalRecords/Systems/CriminalRecordsConsoleSystem.cs
+++ b/Content.Server/CriminalRecords/Systems/CriminalRecordsConsoleSystem.cs
@@ -15,6 +15,10 @@
 using Content.Shared.IdentityManagement;
 using Content.Shared.Security.Components;
 
+// CD: imports
+using Content.Server._CD.Records;
+using Content.Shared._CD.Records;
+
 namespace Content.Server.CriminalRecords.Systems;
 
 /// <summary>
@@ -36,6 +40,7 @@ public override void Initialize()
         SubscribeLocalEvent<CriminalRecordsConsoleComponent, RecordModifiedEvent>(UpdateUserInterface);
         SubscribeLocalEvent<CriminalRecordsConsoleComponent, AfterGeneralRecordCreatedEvent>(UpdateUserInterface);
 
+        /* CD: We disable the wizden Criminal Records computer and reuse some of the Bui events
         Subs.BuiEvents<CriminalRecordsConsoleComponent>(CriminalRecordsConsoleKey.Key, subs =>
         {
             subs.Event<BoundUIOpenedEvent>(UpdateUserInterface);
@@ -44,6 +49,17 @@ public override void Initialize()
             subs.Event<CriminalRecordChangeStatus>(OnChangeStatus);
             subs.Event<CriminalRecordAddHistory>(OnAddHistory);
             subs.Event<CriminalRecordDeleteHistory>(OnDeleteHistory);
+        }); */
+
+        // CD: also subscribe to status changes from the CD records console
+        Subs.BuiEvents<CriminalRecordsConsoleComponent>(CharacterRecordConsoleKey.Key, subs =>
+        {
+            subs.Event<SelectStationRecord>(OnKeySelected);
+            subs.Event((Entity<CriminalRecordsConsoleComponent> ent, ref CriminalRecordChangeStatus args) =>
+            {
+                OnChangeStatus(ent, ref args);
+                RaiseLocalEvent(ent, new CharacterRecordsModifiedEvent());
+            });
         });
     }
 
diff --git a/Content.Server/Database/ServerDbBase.cs b/Content.Server/Database/ServerDbBase.cs
index ed22c66360a..6121ab88434 100644
--- a/Content.Server/Database/ServerDbBase.cs
+++ b/Content.Server/Database/ServerDbBase.cs
@@ -18,6 +18,10 @@
 using Robust.Shared.Network;
 using Robust.Shared.Utility;
 
+// CD: imports
+using Content.Server._CD.Records;
+using Content.Shared._CD.Records;
+
 namespace Content.Server.Database
 {
     public abstract class ServerDbBase
@@ -209,10 +213,16 @@ private static HumanoidCharacterProfile ConvertProfiles(Profile profile)
                 }
             }
 
+            // CD: get character records or create default records
+            var cdRecords = profile.CDCharacterRecords != null
+                ? RecordsSerialization.DeserializeJson(profile.CDCharacterRecords)
+                : CharacterRecords.DefaultRecords();
+
             return new HumanoidCharacterProfile(
                 profile.CharacterName,
                 profile.FlavorText,
                 profile.Species,
+                profile.Height,
                 profile.Age,
                 sex,
                 gender,
@@ -232,7 +242,8 @@ private static HumanoidCharacterProfile ConvertProfiles(Profile profile)
                 jobs,
                 (PreferenceUnavailableMode) profile.PreferenceUnavailable,
                 antags.ToList(),
-                traits.ToList()
+                traits.ToList(),
+                cdRecords
             );
         }
 
@@ -253,6 +264,7 @@ private static Profile ConvertProfiles(HumanoidCharacterProfile humanoid, int sl
             profile.Age = humanoid.Age;
             profile.Sex = humanoid.Sex.ToString();
             profile.Gender = humanoid.Gender.ToString();
+            profile.Height = humanoid.Height;
             profile.HairName = appearance.HairStyleId;
             profile.HairColor = appearance.HairColor.ToHex();
             profile.FacialHairName = appearance.FacialHairStyleId;
@@ -285,6 +297,9 @@ private static Profile ConvertProfiles(HumanoidCharacterProfile humanoid, int sl
                         .Select(t => new Trait {TraitName = t})
             );
 
+            // CD: Store records
+            profile.CDCharacterRecords = JsonSerializer.SerializeToDocument(humanoid.CDCharacterRecords ?? CharacterRecords.DefaultRecords());
+
             return profile;
         }
         #endregion
diff --git a/Content.Server/Humanoid/Systems/HumanoidAppearanceSystem.cs b/Content.Server/Humanoid/Systems/HumanoidAppearanceSystem.cs
index a0e9143eda9..8076ce00c8b 100644
--- a/Content.Server/Humanoid/Systems/HumanoidAppearanceSystem.cs
+++ b/Content.Server/Humanoid/Systems/HumanoidAppearanceSystem.cs
@@ -54,6 +54,7 @@ public void CloneAppearance(EntityUid source, EntityUid target, HumanoidAppearan
         targetHumanoid.SkinColor = sourceHumanoid.SkinColor;
         targetHumanoid.EyeColor = sourceHumanoid.EyeColor;
         targetHumanoid.Age = sourceHumanoid.Age;
+        targetHumanoid.Height = sourceHumanoid.Height;
         SetSex(target, sourceHumanoid.Sex, false, targetHumanoid);
         targetHumanoid.CustomBaseLayers = new(sourceHumanoid.CustomBaseLayers);
         targetHumanoid.MarkingSet = new(sourceHumanoid.MarkingSet);
diff --git a/Content.Server/_CD/CryoSleep/CryoSleepSystem.cs b/Content.Server/_CD/CryoSleep/CryoSleepSystem.cs
new file mode 100644
index 00000000000..e407eb52fa0
--- /dev/null
+++ b/Content.Server/_CD/CryoSleep/CryoSleepSystem.cs
@@ -0,0 +1,261 @@
+using Content.Server._CD.Records;
+using Content.Server.Mind;
+using Content.Server.Station.Systems;
+using Content.Server.Forensics;
+using Content.Server.StationRecords.Systems;
+using Content.Server.Chat.Systems;
+using Content.Server.Storage.Components;
+using Content.Server.Storage.EntitySystems;
+using Content.Server.Station.Components;
+using Content.Shared.ActionBlocker;
+using Content.Shared.DragDrop;
+using Content.Shared.Destructible;
+using Content.Shared.Mind;
+using Content.Server.EUI;
+using Content.Server.GameTicking;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Roles.Jobs;
+using Content.Shared.Verbs;
+using Content.Shared.Climbing.Systems;
+using Content.Shared.PDA;
+using Content.Shared.Inventory;
+using Content.Shared.StationRecords;
+using Robust.Shared.Enums;
+using Robust.Server.Containers;
+using Robust.Shared.Containers;
+using Content.Server._CD.Storage.Components;
+
+namespace Content.Server._CD.CryoSleep;
+
+public sealed class CryoSleepSystem : EntitySystem
+{
+    [Dependency] private readonly EuiManager _euiManager = null!;
+    [Dependency] private readonly ActionBlockerSystem _actionBlocker = default!;
+    [Dependency] private readonly ClimbSystem _climb = default!;
+    [Dependency] private readonly StationJobsSystem _stationJobsSystem = default!;
+    [Dependency] private readonly SharedJobSystem _sharedJobSystem = default!;
+    [Dependency] private readonly MindSystem _mindSystem = default!;
+    [Dependency] private readonly ContainerSystem _container = default!;
+    [Dependency] private readonly GameTicker _gameTicker = default!;
+    [Dependency] private readonly InventorySystem _inventory = default!;
+    [Dependency] private readonly StationRecordsSystem _stationRecords = default!;
+    [Dependency] private readonly ChatSystem _chatSystem = default!;
+    [Dependency] private readonly EntityStorageSystem _entityStorage = default!;
+    [Dependency] private readonly StationSystem _station = default!;
+    [Dependency] private readonly CharacterRecordsSystem _characterRecords = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<CryoSleepComponent, ComponentInit>(ComponentInit);
+        SubscribeLocalEvent<CryoSleepComponent, GetVerbsEvent<AlternativeVerb>>(AddAlternativeVerbs);
+        SubscribeLocalEvent<CryoSleepComponent, DestructionEventArgs>((e, c, _) => EjectBody(e, c));
+        SubscribeLocalEvent<CryoSleepComponent, DragDropTargetEvent>(OnDragDrop);
+    }
+
+    private void ComponentInit(EntityUid uid, CryoSleepComponent component, ComponentInit args)
+    {
+        component.BodyContainer = _container.EnsureContainer<ContainerSlot>(uid, "body_container");
+    }
+
+    private bool InsertBody(EntityUid uid, EntityUid? toInsert, CryoSleepComponent component)
+    {
+        if (toInsert == null || IsOccupied(component))
+            return false;
+
+        if (!HasComp<MobStateComponent>(toInsert.Value))
+            return false;
+
+        var inserted = _container.Insert(toInsert.Value, component.BodyContainer);
+
+        return inserted;
+    }
+
+    public bool RespawnUser(EntityUid? toInsert, CryoSleepComponent component, bool force)
+    {
+        if (toInsert == null)
+            return false;
+
+        if (IsOccupied(component) && !force)
+            return false;
+
+        if (_mindSystem.TryGetMind(toInsert.Value, out var mind, out var mindComp))
+        {
+            var session = mindComp.Session;
+            if (session != null && session.Status == SessionStatus.Disconnected)
+            {
+                InsertBody(toInsert.Value, component.Owner, component);
+                return true;
+            }
+        }
+
+        var success = _container.Insert(toInsert.Value, component.BodyContainer);
+
+        if (success && mindComp?.Session != null)
+        {
+            _euiManager.OpenEui(new CryoSleepEui(mind, this), mindComp.Session);
+        }
+
+        return success;
+    }
+    public void CryoStoreBody(EntityUid mindId)
+    {
+        if (!_sharedJobSystem.MindTryGetJob(mindId, out _, out var prototype))
+            return;
+
+        if (!TryComp<MindComponent>(mindId, out var mind))
+            return;
+
+        var body = mind.CurrentEntity;
+        var job = prototype;
+
+        var name = mind.CharacterName;
+
+        if (body == null)
+            return;
+
+        // Remove the record. Hopefully.
+        foreach (var item in _inventory.GetHandOrInventoryEntities(body.Value))
+        {
+            if (TryComp(item, out PdaComponent? pda) && TryComp(pda.ContainedId, out StationRecordKeyStorageComponent? keyStorage) && keyStorage.Key is { } key && _stationRecords.TryGetRecord(key, out GeneralStationRecord? record))
+            {
+                if (TryComp(body, out DnaComponent? dna) &&
+                    dna.DNA != record.DNA)
+                {
+                    continue;
+                }
+
+                if (TryComp(body, out FingerprintComponent? fingerPrint) &&
+                    fingerPrint.Fingerprint != record.Fingerprint)
+                {
+                    continue;
+                }
+
+                _stationRecords.RemoveRecord(key);
+                Del(item);
+            }
+        }
+
+        if (TryComp<CharacterRecordKeyStorageComponent>(body, out var recordKey))
+        {
+            _characterRecords.DeleteAllRecords(body.Value, recordKey);
+        }
+
+        // Move their items
+        MoveItems(body.Value);
+
+        _gameTicker.OnGhostAttempt(mindId, false, true, mind: mind);
+        EntityManager.DeleteEntity(body);
+
+        if (!TryComp<MindComponent>(mindId, out var mindComp) || mindComp.UserId == null)
+            return;
+
+        foreach (var station in _station.GetStationsSet())
+        {
+            if (!TryComp<StationJobsComponent>(station, out var stationJobs))
+               continue;
+
+            if (!_stationJobsSystem.TryGetPlayerJobs(station, mindComp.UserId.Value, out var jobs, stationJobs))
+                continue;
+
+            foreach (var item in jobs)
+            {
+               _stationJobsSystem.TryAdjustJobSlot(station, item, 1, clamp: true);
+               _chatSystem.DispatchStationAnnouncement(station, Loc.GetString("cryo-leave-announcement", ("character", name!), ("job", job.LocalizedName)), "Cryo Pod", false);
+            }
+
+            _stationJobsSystem.TryRemovePlayerJobs(station, mindComp.UserId.Value, stationJobs);
+        }
+    }
+
+    private bool EjectBody(EntityUid pod, CryoSleepComponent component)
+    {
+        if (!IsOccupied(component))
+            return false;
+
+        var toEject = component.BodyContainer.ContainedEntity;
+        if (toEject == null)
+            return false;
+
+        _container.Remove(toEject.Value, component.BodyContainer);
+        _climb.ForciblySetClimbing(toEject.Value, pod);
+
+        return true;
+    }
+
+    private bool IsOccupied(CryoSleepComponent component)
+    {
+        return component.BodyContainer.ContainedEntity != null;
+    }
+
+    private void AddAlternativeVerbs(EntityUid uid, CryoSleepComponent component, GetVerbsEvent<AlternativeVerb> args)
+    {
+        if (!args.CanAccess || !args.CanInteract)
+            return;
+
+        // Insert self verb
+        if (!IsOccupied(component) &&
+            _actionBlocker.CanMove(args.User))
+        {
+            AlternativeVerb verb = new()
+            {
+                Act = () => RespawnUser(args.User, component, false),
+                Category = VerbCategory.Insert,
+                Text = Loc.GetString("medical-scanner-verb-enter")
+            };
+            args.Verbs.Add(verb);
+        }
+
+        // Eject somebody verb
+        if (IsOccupied(component))
+        {
+            AlternativeVerb verb = new()
+            {
+                Act = () => EjectBody(component.Owner, component),
+                Category = VerbCategory.Eject,
+                Text = Loc.GetString("medical-scanner-verb-noun-occupant")
+            };
+            args.Verbs.Add(verb);
+        }
+    }
+
+    private void OnDragDrop(EntityUid uid, CryoSleepComponent component, ref DragDropTargetEvent args)
+    {
+        if (args.Handled || args.User != args.Dragged)
+            return;
+
+        RespawnUser(args.User, component, false);
+    }
+
+    private void MoveItems(EntityUid uid)
+    {
+        //// Make sure the entity being cryo'd has an inventory
+        //if (!HasComp<EntityStorageComponent>(uid))
+        //    return;
+
+        // Get the locker
+        var query = EntityQueryEnumerator<LostAndFoundComponent>();
+        query.MoveNext(out var locker, out var lostAndFoundComponent);
+
+        // Make sure the locker exists and has storage
+        if (!locker.Valid)
+            return;
+
+        TryComp<EntityStorageComponent>(uid, out var lockerStorageComp);
+
+        var coordinates = Transform(locker).Coordinates;
+
+        // Go through their inventory and put everything in a locker
+        foreach (var item in _inventory.GetHandOrInventoryEntities(uid))
+        {
+            if (!item.IsValid() || !TryComp<MetaDataComponent>(item, out var comp))
+                continue;
+
+            var proto = comp.EntityPrototype;
+            var ent = EntityManager.SpawnEntity(proto!.ID, coordinates);
+
+            _entityStorage.Insert(ent, locker, lockerStorageComp);
+        }
+    }
+}
diff --git a/Content.Server/_CD/Records/CharacterRecordKeyStorageComponent.cs b/Content.Server/_CD/Records/CharacterRecordKeyStorageComponent.cs
new file mode 100644
index 00000000000..29e56e386d0
--- /dev/null
+++ b/Content.Server/_CD/Records/CharacterRecordKeyStorageComponent.cs
@@ -0,0 +1,17 @@
+namespace Content.Server._CD.Records;
+
+/// <summary>
+/// Stores the key to the entities character records.
+/// </summary>
+[RegisterComponent]
+[Access(typeof(CharacterRecordsSystem))]
+public sealed partial class CharacterRecordKeyStorageComponent : Component
+{
+    [ViewVariables(VVAccess.ReadOnly)]
+    public CharacterRecordKey Key;
+
+    public CharacterRecordKeyStorageComponent(CharacterRecordKey key)
+    {
+        Key = key;
+    }
+}
diff --git a/Content.Server/_CD/Records/CharacterRecordsComponent.cs b/Content.Server/_CD/Records/CharacterRecordsComponent.cs
new file mode 100644
index 00000000000..9ba6dd5529d
--- /dev/null
+++ b/Content.Server/_CD/Records/CharacterRecordsComponent.cs
@@ -0,0 +1,31 @@
+using Content.Shared._CD.Records;
+
+namespace Content.Server._CD.Records;
+
+/// <summary>
+/// The component on the station that stores records after the round starts.
+/// </summary>
+[RegisterComponent]
+[Access(typeof(CharacterRecordsSystem))]
+public sealed partial class CharacterRecordsComponent : Component
+{
+    [ViewVariables(VVAccess.ReadOnly)]
+    public Dictionary<uint, FullCharacterRecords> Records = new();
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    private uint _nextKey = 1;
+
+    /// <summary>
+    /// Creates a key has never been used previously
+    /// </summary>
+    public uint CreateNewKey()
+    {
+        return _nextKey++;
+    }
+}
+
+public sealed record CharacterRecordKey
+{
+    public EntityUid Station { get; init; }
+    public uint Index { get; init; }
+}
diff --git a/Content.Server/_CD/Records/CharacterRecordsSystem.cs b/Content.Server/_CD/Records/CharacterRecordsSystem.cs
new file mode 100644
index 00000000000..615b0137891
--- /dev/null
+++ b/Content.Server/_CD/Records/CharacterRecordsSystem.cs
@@ -0,0 +1,176 @@
+using Content.Server.Forensics;
+using Content.Server.GameTicking;
+using Content.Server.StationRecords;
+using Content.Server.StationRecords.Systems;
+using Content.Shared._CD.Records;
+using Content.Shared.Inventory;
+using Content.Shared.PDA;
+using Content.Shared.Roles;
+using Content.Shared.StationRecords;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._CD.Records;
+
+public sealed class CharacterRecordsSystem : EntitySystem
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly InventorySystem _inventorySystem = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PlayerSpawnCompleteEvent>(OnPlayerSpawn, after: new []{ typeof(StationRecordsSystem) });
+    }
+
+    private void OnPlayerSpawn(PlayerSpawnCompleteEvent args)
+    {
+        if (!HasComp<StationRecordsComponent>(args.Station))
+        {
+            Log.Error("Tried to add CharacterRecords on a station without StationRecords");
+            return;
+        }
+        if (!HasComp<CharacterRecordsComponent>(args.Station))
+            AddComp<CharacterRecordsComponent>(args.Station);
+
+        var profile = args.Profile;
+        if (profile.CDCharacterRecords == null || string.IsNullOrEmpty(args.JobId))
+            return;
+
+        var player = args.Mob;
+
+        if (!_prototypeManager.TryIndex(args.JobId, out JobPrototype? jobPrototype))
+        {
+            throw new ArgumentException($"Invalid job prototype ID: {args.JobId}");
+        }
+
+        TryComp<FingerprintComponent>(player, out var fingerprintComponent);
+        TryComp<DnaComponent>(player, out var dnaComponent);
+
+        var records = new FullCharacterRecords(
+            characterRecords: new CharacterRecords(profile.CDCharacterRecords),
+            stationRecordsKey: FindStationRecordsKey(player),
+            name: profile.Name,
+            age: profile.Age,
+            species: profile.Species,
+            jobTitle: jobPrototype.LocalizedName,
+            jobIcon: jobPrototype.Icon,
+            gender: profile.Gender,
+            sex: profile.Sex,
+            fingerprint: fingerprintComponent?.Fingerprint,
+            dna: dnaComponent?.DNA,
+            owner: player);
+        AddRecord(args.Station, args.Mob, records);
+    }
+
+    private uint? FindStationRecordsKey(EntityUid uid)
+    {
+        if (!_inventorySystem.TryGetSlotEntity(uid, "id", out var idUid))
+            return null;
+
+        var keyStorageEntity = idUid;
+        if (TryComp<PdaComponent>(idUid, out var pda) && pda.ContainedId is {} id)
+        {
+            keyStorageEntity = id;
+        }
+
+        if (!TryComp<StationRecordKeyStorageComponent>(keyStorageEntity, out var storage))
+        {
+            return null;
+        }
+
+        return storage.Key?.Id;
+    }
+
+    private void AddRecord(EntityUid station, EntityUid player, FullCharacterRecords records, CharacterRecordsComponent? recordsDb = null)
+    {
+        if (!Resolve(station, ref recordsDb))
+            return;
+
+        uint key = recordsDb.CreateNewKey();
+        recordsDb.Records.Add(key, records);
+        var playerKey = new CharacterRecordKey { Station = station, Index = key };
+        AddComp(player, new CharacterRecordKeyStorageComponent(playerKey));
+
+        RaiseLocalEvent(station, new CharacterRecordsModifiedEvent());
+    }
+
+    public void DelEntry(
+        EntityUid station,
+        EntityUid player,
+        CharacterRecordType ty,
+        int idx,
+        CharacterRecordsComponent? recordsDb = null,
+        CharacterRecordKeyStorageComponent? key = null)
+    {
+        if (!Resolve(station, ref recordsDb) || !Resolve(player, ref key))
+            return;
+
+        if (!recordsDb.Records.ContainsKey(key.Key.Index))
+            return;
+
+        var cr = recordsDb.Records[key.Key.Index].CharacterRecords;
+
+        switch (ty)
+        {
+            case CharacterRecordType.Employment:
+                cr.EmploymentEntries.RemoveAt(idx);
+                break;
+            case CharacterRecordType.Medical:
+                cr.MedicalEntries.RemoveAt(idx);
+                break;
+            case CharacterRecordType.Security:
+                cr.SecurityEntries.RemoveAt(idx);
+                break;
+        }
+
+        RaiseLocalEvent(station, new CharacterRecordsModifiedEvent());
+    }
+
+    public void ResetRecord(
+        EntityUid station,
+        EntityUid player,
+        CharacterRecordsComponent? recordsDb = null,
+        CharacterRecordKeyStorageComponent? key = null)
+    {
+        if (!Resolve(station, ref recordsDb) || !Resolve(player, ref key))
+            return;
+
+        if (!recordsDb.Records.ContainsKey(key.Key.Index))
+            return;
+
+        var records = CharacterRecords.DefaultRecords();
+        recordsDb.Records[key.Key.Index].CharacterRecords = records;
+        RaiseLocalEvent(station, new CharacterRecordsModifiedEvent());
+    }
+
+    public void DeleteAllRecords(EntityUid player, CharacterRecordKeyStorageComponent? key = null)
+    {
+        if (!Resolve(player, ref key))
+            return;
+
+        var station = key.Key.Station;
+        CharacterRecordsComponent? records = null;
+        if (!Resolve(station, ref records))
+            return;
+
+        records.Records.Remove(key.Key.Index);
+    }
+
+    public IDictionary<uint, FullCharacterRecords> QueryRecords(EntityUid station, CharacterRecordsComponent? recordsDb = null)
+    {
+        if (!Resolve(station, ref recordsDb))
+            return new Dictionary<uint, FullCharacterRecords>();
+
+        return recordsDb.Records;
+    }
+}
+
+public sealed class CharacterRecordsModifiedEvent : EntityEventArgs
+{
+
+    public CharacterRecordsModifiedEvent()
+    {
+    }
+}
diff --git a/Content.Server/_CD/Records/Commands/DelRecordEntryCommand.cs b/Content.Server/_CD/Records/Commands/DelRecordEntryCommand.cs
new file mode 100644
index 00000000000..448965703cb
--- /dev/null
+++ b/Content.Server/_CD/Records/Commands/DelRecordEntryCommand.cs
@@ -0,0 +1,55 @@
+using Content.Server.Administration;
+using Content.Server.Station.Systems;
+using Content.Shared._CD.Records;
+using Content.Shared.Administration;
+using Robust.Shared.Console;
+
+namespace Content.Server._CD.Records.Commands;
+
+[AdminCommand(AdminFlags.Ban)]
+public sealed class DelRecordEntryCommand : IConsoleCommand
+{
+    [Dependency] private readonly IEntityManager _entManager = default!;
+
+    public string Command => "delrecordentry";
+
+    public string Description =>
+        "Resets the records of the given entity to the default values. This is not saved to the database and only lasts until the round is over";
+
+    public string Help => $"{Command} <entity> <recordType> <index>";
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (args.Length < 3)
+        {
+            shell.WriteLine($"Not enough arguments.\n{Help}");
+            return;
+        }
+
+        if (!NetEntity.TryParse(args[0], out var uidNet) || !_entManager.TryGetEntity(uidNet, out var uid))
+        {
+            shell.WriteLine($"Invalid entity id.");
+            return;
+        }
+
+        if (!Enum.TryParse<CharacterRecordType>(args[1], out var ty))
+        {
+            shell.WriteLine($"Invalid entry type.");
+            return;
+        }
+
+        if (!int.TryParse(args[2], out var idx))
+        {
+            shell.WriteLine($"Invalid index.");
+            return;
+        }
+
+        var characterRecordsSystem = _entManager.System<CharacterRecordsSystem>();
+        var stationSystem = _entManager.System<StationSystem>();
+
+        foreach (var s in stationSystem.GetStations())
+        {
+            characterRecordsSystem.DelEntry(s, uid.Value, ty, idx);
+        }
+    }
+
+}
diff --git a/Content.Server/_CD/Records/Commands/PurgeCharacterRecordsCommand.cs b/Content.Server/_CD/Records/Commands/PurgeCharacterRecordsCommand.cs
new file mode 100644
index 00000000000..6358203ae63
--- /dev/null
+++ b/Content.Server/_CD/Records/Commands/PurgeCharacterRecordsCommand.cs
@@ -0,0 +1,42 @@
+using Content.Server.Administration;
+using Content.Server.Station.Systems;
+using Content.Shared.Administration;
+using Robust.Shared.Console;
+
+namespace Content.Server._CD.Records.Commands;
+
+[AdminCommand(AdminFlags.Ban)]
+public sealed class PurgeCharacterRecordsCommand : IConsoleCommand
+{
+    [Dependency] private readonly IEntityManager _entManager = default!;
+
+    public string Command => "purgecharacterrecords";
+
+    public string Description =>
+        "Resets the records of the given entity to the default values. This is not saved to the database and only lasts until the round is over";
+
+    public string Help => $"{Command} <entity>";
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (args.Length < 1)
+        {
+            shell.WriteLine($"Not enough arguments.\n{Help}");
+            return;
+        }
+
+        if (!NetEntity.TryParse(args[0], out var uidNet) || !_entManager.TryGetEntity(uidNet, out var uid))
+        {
+            shell.WriteLine($"Invalid entity id.");
+            return;
+        }
+
+        var characterRecordsSystem = _entManager.System<CharacterRecordsSystem>();
+        var stationSystem = _entManager.System<StationSystem>();
+
+        foreach (var s in stationSystem.GetStations())
+        {
+            characterRecordsSystem.ResetRecord(s, uid.Value);
+        }
+    }
+
+}
diff --git a/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleComponent.cs b/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleComponent.cs
new file mode 100644
index 00000000000..94d68f58292
--- /dev/null
+++ b/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleComponent.cs
@@ -0,0 +1,17 @@
+using Content.Shared._CD.Records;
+using Content.Shared.StationRecords;
+
+namespace Content.Server._CD.Records.Consoles;
+
+[RegisterComponent]
+public sealed partial class CharacterRecordConsoleComponent : Component
+{
+    [ViewVariables(VVAccess.ReadOnly)]
+    public uint? SelectedIndex { get; set; }
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public StationRecordsFilter? Filter;
+
+    [DataField(required: true), ViewVariables(VVAccess.ReadOnly)]
+    public RecordConsoleType ConsoleType;
+}
diff --git a/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleSystem.cs b/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleSystem.cs
new file mode 100644
index 00000000000..7b7fa442d6d
--- /dev/null
+++ b/Content.Server/_CD/Records/Consoles/CharacterRecordConsoleSystem.cs
@@ -0,0 +1,151 @@
+using Content.Server.Station.Systems;
+using Content.Server.StationRecords;
+using Content.Server.StationRecords.Systems;
+using Content.Shared._CD.Records;
+using Content.Shared.CriminalRecords;
+using Content.Shared.Security;
+using Content.Shared.StationRecords;
+using Robust.Server.GameObjects;
+
+namespace Content.Server._CD.Records.Consoles;
+
+public sealed class CharacterRecordConsoleSystem : EntitySystem
+{
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly UserInterfaceSystem _userInterface = default!;
+    [Dependency] private readonly CharacterRecordsSystem _characterRecords = default!;
+    [Dependency] private readonly StationSystem _stationSystem = default!;
+    [Dependency] private readonly StationRecordsSystem _stationRecords = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<CharacterRecordConsoleComponent, CharacterRecordsModifiedEvent>((uid, component, _) => UpdateUi(uid, component));
+
+        Subs.BuiEvents<CharacterRecordConsoleComponent>(CharacterRecordConsoleKey.Key, subr =>
+        {
+            subr.Event<BoundUIOpenedEvent>((uid, component, _) => UpdateUi(uid, component));
+            subr.Event<CharacterRecordConsoleSelectMsg>(OnKeySelect);
+            subr.Event<CharacterRecordsConsoleFilterMsg>(OnFilterApplied);
+        });
+    }
+
+    private void OnFilterApplied(EntityUid entity, CharacterRecordConsoleComponent console,
+        CharacterRecordsConsoleFilterMsg msg)
+    {
+        console.Filter = msg.Filter;
+        UpdateUi(entity, console);
+    }
+
+    private void OnKeySelect(EntityUid entity, CharacterRecordConsoleComponent console,
+        CharacterRecordConsoleSelectMsg msg)
+    {
+        console.SelectedIndex = msg.Index;
+        UpdateUi(entity, console);
+    }
+
+    private void UpdateUi(EntityUid entity, CharacterRecordConsoleComponent? console = null)
+    {
+        if (!Resolve(entity, ref console))
+            return;
+
+        var station = _stationSystem.GetOwningStation(entity);
+        if (!HasComp<StationRecordsComponent>(station) ||
+            !HasComp<CharacterRecordsComponent>(station))
+        {
+            SendState(entity, new CharacterRecordConsoleState { ConsoleType = console.ConsoleType });
+            return;
+        }
+
+        var characterRecords = _characterRecords.QueryRecords(station.Value);
+        // Get the name and station records key display from the list of records
+        var names = new Dictionary<uint, (string, uint?)>();
+        foreach (var (i, r) in characterRecords)
+        {
+            // Apply any filter the user has set
+            if (console.Filter != null)
+            {
+                if (IsSkippedRecord(console.Filter, r))
+                    continue;
+            }
+
+            if (names.ContainsKey(i))
+                Log.Error($"We somehow have duplicate character record keys, NetEntity: {i}, Entity: {entity}, Character Name: {r.Name}");
+            if (console.ConsoleType == RecordConsoleType.Admin)
+            {
+                var netEnt = _entityManager.GetNetEntity(r.Owner!.Value);
+                // Admins get additional info to make it easier to run commands
+                names[i] = ($"{r.Name} ({netEnt}, {r.JobTitle}", r.StationRecordsKey);
+            }
+            else
+            {
+                names[i] = ($"{r.Name} ({r.JobTitle})", r.StationRecordsKey);
+            }
+        }
+
+        var record =
+            console.SelectedIndex == null || !characterRecords.ContainsKey(console.SelectedIndex!.Value)
+            ? null
+            : characterRecords[console.SelectedIndex.Value];
+        (SecurityStatus, string?)? securityStatus = null;
+
+        // If we need the character's security status, gather it from the criminal records
+        if ((console.ConsoleType == RecordConsoleType.Admin ||
+            console.ConsoleType == RecordConsoleType.Security)
+            && record?.StationRecordsKey != null)
+        {
+            var key = new StationRecordKey(record.StationRecordsKey.Value, station.Value);
+            if (_stationRecords.TryGetRecord<CriminalRecord>(key, out var entry))
+            {
+                securityStatus = (entry.Status, entry.Reason);
+            }
+        }
+
+        SendState(entity,
+            new CharacterRecordConsoleState
+            {
+                ConsoleType = console.ConsoleType,
+                RecordListing = names,
+                SelectedIndex = console.SelectedIndex,
+                SelectedRecord = record,
+                Filter = console.Filter,
+                SelectedSecurityStatus = securityStatus,
+            });
+    }
+
+    private void SendState(EntityUid entity, CharacterRecordConsoleState state)
+    {
+        _userInterface.TrySetUiState(entity, CharacterRecordConsoleKey.Key, state);
+    }
+
+    /// <summary>
+    /// Almost exactly the same as <see cref="StationRecordsSystem.IsSkipped"/>
+    /// </summary>
+    private static bool IsSkippedRecord(StationRecordsFilter filter,
+        FullCharacterRecords record)
+    {
+        bool isFilter = filter.Value.Length > 0;
+
+        if (!isFilter)
+            return false;
+
+        var filterLowerCaseValue = filter.Value.ToLower();
+
+        return filter.Type switch
+        {
+            StationRecordFilterType.Name =>
+                !record.Name.ToLower().Contains(filterLowerCaseValue),
+            StationRecordFilterType.Prints => record.Fingerprint != null
+                && IsFilterWithSomeCodeValue(record.Fingerprint, filterLowerCaseValue),
+            StationRecordFilterType.DNA => record.DNA != null
+                                                && IsFilterWithSomeCodeValue(record.DNA, filterLowerCaseValue),
+            _ => throw new ArgumentOutOfRangeException(nameof(filter), "Invalid Character Record filter type"),
+        };
+    }
+
+    private static bool IsFilterWithSomeCodeValue(string value, string filter)
+    {
+        return !value.ToLower().StartsWith(filter);
+    }
+}
diff --git a/Content.Server/_CD/Records/RecordsSerialization.cs b/Content.Server/_CD/Records/RecordsSerialization.cs
new file mode 100644
index 00000000000..760c6b79215
--- /dev/null
+++ b/Content.Server/_CD/Records/RecordsSerialization.cs
@@ -0,0 +1,92 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using Content.Shared._CD.Records;
+
+namespace Content.Server._CD.Records;
+
+public static class RecordsSerialization
+{
+    private static int DeserializeInt(JsonElement e, string key, int def)
+    {
+        if (e.TryGetProperty(key, out var prop) && prop.TryGetInt32(out var v))
+        {
+            return v;
+        }
+
+        return def;
+    }
+
+    private static bool DeserializeBool(JsonElement e, string key, bool def)
+    {
+        if (e.TryGetProperty(key, out var v))
+        {
+            if (v.ValueKind == JsonValueKind.True)
+                return true;
+            if (v.ValueKind == JsonValueKind.False)
+                return false;
+        }
+
+        return def;
+    }
+
+    [return: NotNullIfNotNull(nameof(def))]
+    private static string? DeserializeString(JsonElement e, string key, string? def)
+    {
+        if (e.TryGetProperty(key, out var v))
+        {
+            if (v.ValueKind == JsonValueKind.String)
+                return v.GetString() ?? def;
+        }
+
+        return def;
+    }
+
+    private static List<CharacterRecords.RecordEntry> DeserializeEntries(JsonElement e, string key)
+    {
+        if (e.TryGetProperty(key, out var arrv))
+        {
+            if (arrv.ValueKind != JsonValueKind.Array)
+                return new List<CharacterRecords.RecordEntry>();
+
+            var res = new List<CharacterRecords.RecordEntry>();
+            for (var i = 0; i < arrv.GetArrayLength(); ++i)
+            {
+                var record = arrv[i];
+                var title = DeserializeString(record, nameof(CharacterRecords.RecordEntry.Title), null);
+                var involved = DeserializeString(record, nameof(CharacterRecords.RecordEntry.Involved), null);
+                var desc = DeserializeString(record, nameof(CharacterRecords.RecordEntry.Description), null);
+                if (title == null || involved == null || desc == null)
+                    return new List<CharacterRecords.RecordEntry>();
+                res.Add(new CharacterRecords.RecordEntry(title, involved, desc));
+            }
+
+            return res;
+        }
+
+        return new List<CharacterRecords.RecordEntry>();
+    }
+
+    /// <summary>
+    /// We need to manually deserialize CharacterRecords because the easy JSON deserializer does not
+    /// do exactly what we want. More specifically, we need to more robustly handle missing and extra fields
+    /// <br />
+    /// <br />
+    /// Missing fields are filled in with their default value, extra fields are simply ignored
+    /// </summary>
+    public static CharacterRecords DeserializeJson(JsonDocument json)
+    {
+        var e = json.RootElement;
+        var def = CharacterRecords.DefaultRecords();
+        return new CharacterRecords(
+            height: DeserializeInt(e, nameof(def.Height), def.Height),
+            weight: DeserializeInt(e, nameof(def.Weight), def.Weight),
+            emergencyContactName: DeserializeString(e, nameof(def.EmergencyContactName), def.EmergencyContactName),
+            hasWorkAuthorization: DeserializeBool(e, nameof(def.HasWorkAuthorization), def.HasWorkAuthorization),
+            identifyingFeatures: DeserializeString(e, nameof(def.IdentifyingFeatures), def.IdentifyingFeatures),
+            allergies: DeserializeString(e, nameof(def.Allergies), def.Allergies), drugAllergies: DeserializeString(e, nameof(def.DrugAllergies), def.DrugAllergies),
+            postmortemInstructions: DeserializeString(e, nameof(def.PostmortemInstructions), def.PostmortemInstructions),
+            medicalEntries: DeserializeEntries(e, nameof(def.MedicalEntries)),
+            securityEntries: DeserializeEntries(e, nameof(def.SecurityEntries)),
+            employmentEntries: DeserializeEntries(e, nameof(def.EmploymentEntries)));
+    }
+}
diff --git a/Content.Shared/Humanoid/HumanoidAppearanceComponent.cs b/Content.Shared/Humanoid/HumanoidAppearanceComponent.cs
index 4785482ada4..89cbe61bd68 100644
--- a/Content.Shared/Humanoid/HumanoidAppearanceComponent.cs
+++ b/Content.Shared/Humanoid/HumanoidAppearanceComponent.cs
@@ -85,6 +85,12 @@ public sealed partial class HumanoidAppearanceComponent : Component
     [ViewVariables(VVAccess.ReadOnly)]
     public Color? CachedFacialHairColor;
 
+    /// <summary>
+    ///     The height of this humanoid.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public float Height = 1f;
+
     /// <summary>
     /// DeltaV - let paradox anomaly be cloned
     /// </summary>
diff --git a/Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs b/Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs
index 8564ebe8e16..35828107d31 100644
--- a/Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs
+++ b/Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs
@@ -99,28 +99,64 @@ public sealed partial class SpeciesPrototype : IPrototype
     /// <summary>
     ///     Characters younger than this are too young to be hired by Nanotrasen.
     /// </summary>
-    [DataField]
+    [DataField("minAge")]
     public int MinAge = 18;
 
     /// <summary>
     ///     Characters younger than this appear young.
     /// </summary>
-    [DataField]
+    [DataField("youngAge")]
     public int YoungAge = 30;
 
     /// <summary>
     ///     Characters older than this appear old. Characters in between young and old age appear middle aged.
     /// </summary>
-    [DataField]
+    [DataField("oldAge")]
     public int OldAge = 60;
 
     /// <summary>
     ///     Characters cannot be older than this. Only used for restrictions...
     ///     although imagine if ghosts could age people WYCI...
     /// </summary>
-    [DataField]
+    [DataField("maxAge")]
     public int MaxAge = 120;
 
+    /// <summary>
+    /// The minimum height for this species
+    /// </summary>
+    [DataField("minHeight")]
+    public float MinHeight = 0.87f; // Horizon - our baseline
+
+    /// <summary>
+    /// The maximum height for this species
+    /// </summary>
+    [DataField("maxHeight")]
+    public float MaxHeight = 1.16f; // Horizon - our baseline
+
+    /// <summary>
+    /// The default height for this species
+    /// </summary>
+    [DataField("defaultHeight")]
+    public float DefaultHeight = 1f;
+
+    /// <summary>
+    /// The default width for this species
+    /// </summary>
+    [DataField("defaultWidth")]
+    public float DefaultWidth = 1f;
+
+    /// <summary>
+    /// Whether to scale horizontally or not
+    /// </summary>
+    [DataField("scaleWidth")]
+    public bool ScaleWidth = true;
+
+    /// <summary>
+    /// Whether to scale vertically or not
+    /// </summary>
+    [DataField("scaleHeight")]
+    public bool ScaleHeight = true;
+
     /// <summary>
     ///     The Style used for the guidebook info link in the character profile editor
     /// </summary>
diff --git a/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs b/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
index 4974e283dd5..99d4c19f076 100644
--- a/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
+++ b/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using System.Numerics;
 using Content.Shared.Decals;
 using Content.Shared.Humanoid.Markings;
 using Content.Shared.Humanoid.Prototypes;
@@ -328,6 +329,7 @@ public virtual void LoadProfile(EntityUid uid, HumanoidCharacterProfile profile,
         }
 
         humanoid.Age = profile.Age;
+		humanoid.Height = profile.Height;
 
         humanoid.LastProfileLoaded = profile; // DeltaV - let paradox anomaly be cloned
 
diff --git a/Content.Shared/Preferences/HumanoidCharacterProfile.cs b/Content.Shared/Preferences/HumanoidCharacterProfile.cs
index 59906538ec5..89f86452331 100644
--- a/Content.Shared/Preferences/HumanoidCharacterProfile.cs
+++ b/Content.Shared/Preferences/HumanoidCharacterProfile.cs
@@ -15,6 +15,9 @@
 using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
 
+// CD: Imports
+using Content.Shared._CD.Records;
+
 namespace Content.Shared.Preferences
 {
     /// <summary>
@@ -35,6 +38,7 @@ private HumanoidCharacterProfile(
             string name,
             string flavortext,
             string species,
+            float height,
             int age,
             Sex sex,
             Gender gender,
@@ -45,11 +49,13 @@ private HumanoidCharacterProfile(
             Dictionary<string, JobPriority> jobPriorities,
             PreferenceUnavailableMode preferenceUnavailable,
             List<string> antagPreferences,
-            List<string> traitPreferences)
+            List<string> traitPreferences,
+            CharacterRecords? cdCharacterRecords)
         {
             Name = name;
             FlavorText = flavortext;
             Species = species;
+            Height = height;
             Age = age;
             Sex = sex;
             Gender = gender;
@@ -61,6 +67,7 @@ private HumanoidCharacterProfile(
             PreferenceUnavailable = preferenceUnavailable;
             _antagPreferences = antagPreferences;
             _traitPreferences = traitPreferences;
+            CDCharacterRecords = cdCharacterRecords;
         }
 
         /// <summary>Copy constructor but with overridable references (to prevent useless copies)</summary>
@@ -69,8 +76,8 @@ private HumanoidCharacterProfile(
             Dictionary<string, JobPriority> jobPriorities,
             List<string> antagPreferences,
             List<string> traitPreferences)
-            : this(other.Name, other.FlavorText, other.Species, other.Age, other.Sex, other.Gender, other.Appearance, other.Clothing, other.Backpack, other.SpawnPriority,
-                jobPriorities, other.PreferenceUnavailable, antagPreferences, traitPreferences)
+            : this(other.Name, other.FlavorText, other.Species, other.Height, other.Age, other.Sex, other.Gender, other.Appearance, other.Clothing, other.Backpack, other.SpawnPriority,
+                jobPriorities, other.PreferenceUnavailable, antagPreferences, traitPreferences, other.CDCharacterRecords)
         {
         }
 
@@ -84,6 +91,7 @@ public HumanoidCharacterProfile(
             string name,
             string flavortext,
             string species,
+            float height,
             int age,
             Sex sex,
             Gender gender,
@@ -94,9 +102,10 @@ public HumanoidCharacterProfile(
             IReadOnlyDictionary<string, JobPriority> jobPriorities,
             PreferenceUnavailableMode preferenceUnavailable,
             IReadOnlyList<string> antagPreferences,
-            IReadOnlyList<string> traitPreferences)
-            : this(name, flavortext, species, age, sex, gender, appearance, clothing, backpack, spawnPriority, new Dictionary<string, JobPriority>(jobPriorities),
-                preferenceUnavailable, new List<string>(antagPreferences), new List<string>(traitPreferences))
+            IReadOnlyList<string> traitPreferences,
+            CharacterRecords? cdCharacterRecords)
+            : this(name, flavortext, species, height, age, sex, gender, appearance, clothing, backpack, spawnPriority, new Dictionary<string, JobPriority>(jobPriorities),
+                preferenceUnavailable, new List<string>(antagPreferences), new List<string>(traitPreferences), cdCharacterRecords)
         {
         }
 
@@ -109,6 +118,7 @@ public HumanoidCharacterProfile() : this(
             "John Doe",
             "",
             SharedHumanoidAppearanceSystem.DefaultSpecies,
+            1f,
             18,
             Sex.Male,
             Gender.Male,
@@ -122,7 +132,8 @@ public HumanoidCharacterProfile() : this(
             },
             PreferenceUnavailableMode.SpawnAsOverflow,
             new List<string>(),
-            new List<string>())
+            new List<string>(),
+            null)
         {
         }
 
@@ -137,6 +148,7 @@ public static HumanoidCharacterProfile DefaultWithSpecies(string species = Share
                 "John Doe",
                 "",
                 species,
+                1f,
                 18,
                 Sex.Male,
                 Gender.Male,
@@ -150,7 +162,8 @@ public static HumanoidCharacterProfile DefaultWithSpecies(string species = Share
                 },
                 PreferenceUnavailableMode.SpawnAsOverflow,
                 new List<string>(),
-                new List<string>());
+                new List<string>(),
+                null);
         }
 
         // TODO: This should eventually not be a visual change only.
@@ -175,10 +188,13 @@ public static HumanoidCharacterProfile RandomWithSpecies(string species = Shared
 
             var sex = Sex.Unsexed;
             var age = 18;
+            var height = 1f;
             if (prototypeManager.TryIndex<SpeciesPrototype>(species, out var speciesPrototype))
             {
                 sex = random.Pick(speciesPrototype.Sexes);
                 age = random.Next(speciesPrototype.MinAge, speciesPrototype.OldAge); // people don't look and keep making 119 year old characters with zero rp, cap it at middle aged
+                // CD: We only permit 2 decimals of precision for height in the editor, so we should enforce that here
+                height = MathF.Round(random.NextFloat(speciesPrototype.MinHeight, speciesPrototype.MaxHeight), 2);
             }
 
             var gender = Gender.Epicene;
@@ -195,17 +211,22 @@ public static HumanoidCharacterProfile RandomWithSpecies(string species = Shared
 
             var name = GetName(species, gender);
 
-            return new HumanoidCharacterProfile(name, "", species, age, sex, gender, HumanoidCharacterAppearance.Random(species, sex), ClothingPreference.Jumpsuit, BackpackPreference.Backpack, SpawnPriorityPreference.None,
+            return new HumanoidCharacterProfile(name, "", species, height, age, sex, gender, HumanoidCharacterAppearance.Random(species, sex), ClothingPreference.Jumpsuit, BackpackPreference.Backpack, SpawnPriorityPreference.None,
                 new Dictionary<string, JobPriority>
                 {
                     {SharedGameTicker.FallbackOverflowJob, JobPriority.High},
-                }, PreferenceUnavailableMode.StayInLobby, new List<string>(), new List<string>());
+                }, PreferenceUnavailableMode.StayInLobby, new List<string>(), new List<string>(), null);
         }
 
         public string Name { get; private set; }
         public string FlavorText { get; private set; }
         public string Species { get; private set; }
 
+        public CharacterRecords? CDCharacterRecords { get; private set; }
+
+        [DataField("height")]
+        public float Height { get; private set; }
+
         [DataField("age")]
         public int Age { get; private set; }
 
@@ -257,6 +278,10 @@ public HumanoidCharacterProfile WithSpecies(string species)
             return new(this) { Species = species };
         }
 
+        public HumanoidCharacterProfile WithHeight(float height)
+        {
+            return new(this) { Height = height };
+        }
 
         public HumanoidCharacterProfile WithCharacterAppearance(HumanoidCharacterAppearance appearance)
         {
@@ -346,6 +371,11 @@ public HumanoidCharacterProfile WithTraitPreference(string traitId, bool pref)
             return new(this, _jobPriorities, _antagPreferences, list);
         }
 
+        public HumanoidCharacterProfile WithCDCharacterRecords(CharacterRecords records)
+        {
+            return new HumanoidCharacterProfile(this) { CDCharacterRecords = records };
+        }
+
         public string Summary =>
             Loc.GetString(
                 "humanoid-character-profile-summary",
@@ -359,6 +389,7 @@ public bool MemberwiseEquals(ICharacterProfile maybeOther)
             if (maybeOther is not HumanoidCharacterProfile other) return false;
             if (Name != other.Name) return false;
             if (Age != other.Age) return false;
+            if (Height != other.Height) return false;
             if (Sex != other.Sex) return false;
             if (Gender != other.Gender) return false;
             if (PreferenceUnavailable != other.PreferenceUnavailable) return false;
@@ -368,6 +399,8 @@ public bool MemberwiseEquals(ICharacterProfile maybeOther)
             if (!_jobPriorities.SequenceEqual(other._jobPriorities)) return false;
             if (!_antagPreferences.SequenceEqual(other._antagPreferences)) return false;
             if (!_traitPreferences.SequenceEqual(other._traitPreferences)) return false;
+            if (CDCharacterRecords != null && other.CDCharacterRecords != null &&
+                !CDCharacterRecords.MemberwiseEquals(other.CDCharacterRecords)) return false;
             return Appearance.MemberwiseEquals(other.Appearance);
         }
 
@@ -455,6 +488,10 @@ public void EnsureValid(IConfigurationManager configManager, IPrototypeManager p
                 flavortext = FormattedMessage.RemoveMarkup(FlavorText);
             }
 
+            var height = Height;
+            if (speciesPrototype != null)
+                height = Math.Clamp(MathF.Round(Height, 1), speciesPrototype.MinHeight, speciesPrototype.MaxHeight);
+
             var appearance = HumanoidCharacterAppearance.EnsureValid(Appearance, Species, Sex);
 
             var prefsUnavailableMode = PreferenceUnavailable switch
@@ -508,6 +545,7 @@ public void EnsureValid(IConfigurationManager configManager, IPrototypeManager p
             Name = name;
             FlavorText = flavortext;
             Age = age;
+            Height = height;
             Sex = sex;
             Gender = gender;
             Appearance = appearance;
@@ -529,6 +567,8 @@ public void EnsureValid(IConfigurationManager configManager, IPrototypeManager p
 
             _traitPreferences.Clear();
             _traitPreferences.AddRange(traits);
+
+            CDCharacterRecords?.EnsureValid();
         }
 
         public ICharacterProfile Validated(IConfigurationManager configManager, IPrototypeManager prototypeManager)
@@ -564,6 +604,7 @@ public override int GetHashCode()
                     Clothing,
                     Backpack
                 ),
+                Height,
                 SpawnPriority,
                 PreferenceUnavailable,
                 _jobPriorities,
diff --git a/Content.Shared/_CD/Records/CharacterRecords.cs b/Content.Shared/_CD/Records/CharacterRecords.cs
new file mode 100644
index 00000000000..93296eec48d
--- /dev/null
+++ b/Content.Shared/_CD/Records/CharacterRecords.cs
@@ -0,0 +1,252 @@
+using System.Linq;
+using Content.Shared.Preferences;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._CD.Records;
+
+[Serializable, NetSerializable]
+public sealed class CharacterRecords
+{
+    private const int TextMedLen = 128;
+    private const int TextVeryLargeLen = 2048;
+
+    /* Basic info */
+
+    // Additional data is fetched from the Profile
+
+    // All
+    public const int MaxHeight = 800;
+    public int Height { get; private set; }
+    public const int MaxWeight = 300;
+    public int Weight { get; private set; }
+    public string EmergencyContactName { get; private set; }
+
+    // Employment
+    public bool HasWorkAuthorization { get; private set; }
+
+    // Security
+    public string IdentifyingFeatures { get; private set; }
+
+    // Medical
+    public string Allergies { get; private set; }
+    public string DrugAllergies { get; private set; }
+    public string PostmortemInstructions { get; private set; }
+    // history, prescriptions, etc. would be a record below
+
+    // "incidents"
+    public List<RecordEntry> MedicalEntries { get; private set; }
+    public List<RecordEntry> SecurityEntries { get; private set; }
+    public List<RecordEntry> EmploymentEntries { get; private set; }
+
+    [Serializable, NetSerializable]
+    public sealed class RecordEntry
+    {
+        public string Title { get; private set; }
+        // players involved, can be left blank (or with a generic "CentCom" etc.) for backstory related issues
+        public string Involved { get; private set; }
+        // Longer description of events.
+        public string Description { get; private set; }
+
+        public RecordEntry(string title, string involved, string desc)
+        {
+            Title = title;
+            Involved = involved;
+            Description = desc;
+        }
+
+        public RecordEntry(RecordEntry other)
+        : this(other.Title, other.Involved, other.Description)
+        {
+        }
+
+        public bool MemberwiseEquals(RecordEntry other)
+        {
+            return Title == other.Title && Involved == other.Involved && Description == other.Description;
+        }
+
+        public void EnsureValid()
+        {
+            Title = ClampString(Title, TextMedLen);
+            if (Title.Length == 0)
+            {
+                // If the user does not proved a title, give it something so it is not blank
+                Title = Loc.GetString("cd-records-entry-default-title");
+            }
+            Involved = ClampString(Involved, TextMedLen);
+            Description = ClampString(Description, TextVeryLargeLen);
+        }
+    }
+
+    public CharacterRecords(
+        bool hasWorkAuthorization,
+        int height, int weight,
+        string emergencyContactName,
+        string identifyingFeatures,
+        string allergies, string drugAllergies,
+        string postmortemInstructions,
+        List<RecordEntry> medicalEntries, List<RecordEntry> securityEntries, List<RecordEntry> employmentEntries)
+    {
+        HasWorkAuthorization = hasWorkAuthorization;
+        Height = height;
+        Weight = weight;
+        EmergencyContactName = emergencyContactName;
+        IdentifyingFeatures = identifyingFeatures;
+        Allergies = allergies;
+        DrugAllergies = drugAllergies;
+        PostmortemInstructions = postmortemInstructions;
+        MedicalEntries = medicalEntries;
+        SecurityEntries = securityEntries;
+        EmploymentEntries = employmentEntries;
+    }
+
+    public CharacterRecords(CharacterRecords other)
+    {
+        Height = other.Height;
+        Weight = other.Weight;
+        EmergencyContactName = other.EmergencyContactName;
+        HasWorkAuthorization = other.HasWorkAuthorization;
+        IdentifyingFeatures = other.IdentifyingFeatures;
+        Allergies = other.Allergies;
+        DrugAllergies = other.DrugAllergies;
+        PostmortemInstructions = other.PostmortemInstructions;
+        MedicalEntries = other.MedicalEntries.Select(x => new RecordEntry(x)).ToList();
+        SecurityEntries = other.SecurityEntries.Select(x => new RecordEntry(x)).ToList();
+        EmploymentEntries = other.EmploymentEntries.Select(x => new RecordEntry(x)).ToList();
+    }
+
+    public static CharacterRecords DefaultRecords()
+    {
+        return new CharacterRecords(
+            hasWorkAuthorization: true,
+            height: 170, weight: 70,
+            emergencyContactName: "",
+            identifyingFeatures: "",
+            allergies: "None",
+            drugAllergies: "None",
+            postmortemInstructions: "Return home",
+            medicalEntries: new List<RecordEntry>(),
+            securityEntries: new List<RecordEntry>(),
+            employmentEntries: new List<RecordEntry>()
+        );
+    }
+
+    public bool MemberwiseEquals(CharacterRecords other)
+    {
+        // This is ugly but is only used for integration tests.
+        var test = Height == other.Height
+                   && Weight == other.Weight
+                   && EmergencyContactName == other.EmergencyContactName
+                   && HasWorkAuthorization == other.HasWorkAuthorization
+                   && IdentifyingFeatures == other.IdentifyingFeatures
+                   && Allergies == other.Allergies
+                   && DrugAllergies == other.DrugAllergies
+                   && PostmortemInstructions == other.PostmortemInstructions;
+        if (!test)
+            return false;
+        if (MedicalEntries.Count != other.MedicalEntries.Count)
+            return false;
+        if (SecurityEntries.Count != other.SecurityEntries.Count)
+            return false;
+        if (EmploymentEntries.Count != other.EmploymentEntries.Count)
+            return false;
+        if (MedicalEntries.Where((t, i) => !t.MemberwiseEquals(other.MedicalEntries[i])).Any())
+        {
+            return false;
+        }
+        if (SecurityEntries.Where((t, i) => !t.MemberwiseEquals(other.SecurityEntries[i])).Any())
+        {
+            return false;
+        }
+        if (EmploymentEntries.Where((t, i) => !t.MemberwiseEquals(other.EmploymentEntries[i])).Any())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static string ClampString(string str, int maxLen)
+    {
+        if (str.Length > maxLen)
+        {
+            return str[..maxLen];
+        }
+        return str;
+    }
+
+    private static void EnsureValidEntries(List<RecordEntry> entries)
+    {
+        foreach (var entry in entries)
+        {
+            entry.EnsureValid();
+        }
+    }
+
+    /// <summary>
+    /// Clamp invalid entries to valid values
+    /// </summary>
+    public void EnsureValid()
+    {
+        Height = Math.Clamp(Height, 0, MaxHeight);
+        Weight = Math.Clamp(Weight, 0, MaxWeight);
+        EmergencyContactName =
+            ClampString(EmergencyContactName, TextMedLen);
+        IdentifyingFeatures = ClampString(IdentifyingFeatures, TextMedLen);
+        Allergies = ClampString(Allergies, TextMedLen);
+        DrugAllergies = ClampString(DrugAllergies, TextMedLen);
+        PostmortemInstructions = ClampString(PostmortemInstructions, TextMedLen);
+
+        EnsureValidEntries(EmploymentEntries);
+        EnsureValidEntries(MedicalEntries);
+        EnsureValidEntries(SecurityEntries);
+    }
+    public CharacterRecords WithHeight(int height)
+    {
+        return new(this) { Height = height };
+    }
+    public CharacterRecords WithWeight(int weight)
+    {
+        return new(this) { Weight = weight };
+    }
+    public CharacterRecords WithWorkAuth(bool auth)
+    {
+        return new(this) { HasWorkAuthorization = auth };
+    }
+    public CharacterRecords WithContactName(string name)
+    {
+        return new(this) { EmergencyContactName = name};
+    }
+    public CharacterRecords WithIdentifyingFeatures(string feat)
+    {
+        return new(this) { IdentifyingFeatures = feat};
+    }
+    public CharacterRecords WithAllergies(string s)
+    {
+        return new(this) { Allergies = s };
+    }
+    public CharacterRecords WithDrugAllergies(string s)
+    {
+        return new(this) { DrugAllergies = s };
+    }
+    public CharacterRecords WithPostmortemInstructions(string s)
+    {
+        return new(this) { PostmortemInstructions = s};
+    }
+    public CharacterRecords WithEmploymentEntries(List<RecordEntry> entries)
+    {
+        return new(this) { EmploymentEntries = entries};
+    }
+    public CharacterRecords WithMedicalEntries(List<RecordEntry> entries)
+    {
+        return new(this) { MedicalEntries = entries};
+    }
+    public CharacterRecords WithSecurityEntries(List<RecordEntry> entries)
+    {
+        return new(this) { SecurityEntries = entries};
+    }
+}
+
+public enum CharacterRecordType : byte
+{
+    Employment, Medical, Security
+}
diff --git a/Content.Shared/_CD/Records/FullCharacterRecords.cs b/Content.Shared/_CD/Records/FullCharacterRecords.cs
new file mode 100644
index 00000000000..e262bbbf226
--- /dev/null
+++ b/Content.Shared/_CD/Records/FullCharacterRecords.cs
@@ -0,0 +1,109 @@
+using Content.Shared.Humanoid;
+using Robust.Shared.Enums;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._CD.Records;
+
+/// <summary>
+/// Contains the full records information, not just stuff that is in the database.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class FullCharacterRecords
+{
+    [ViewVariables]
+    public CharacterRecords CharacterRecords;
+
+    /// <summary>
+    /// Key for the equivalent entry in the station records
+    /// </summary>
+    [ViewVariables]
+    public uint? StationRecordsKey;
+
+    /// <summary>
+    ///     Name tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public string Name;
+
+    /// <summary>
+    ///     Age of the person that this record represents.
+    /// </summary>
+    [ViewVariables]
+    public int Age;
+
+    /// <summary>
+    ///     Job title tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public string JobTitle;
+
+    /// <summary>
+    ///     Job icon tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public string JobIcon;
+
+    /// <summary>
+    ///     Species tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public string Species;
+
+    /// <summary>
+    ///     Gender identity tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public Gender Gender;
+
+    /// <summary>
+    ///     Sex identity tied to this record.
+    /// </summary>
+    [ViewVariables]
+    public Sex Sex;
+
+    [ViewVariables]
+    public string? Fingerprint;
+
+    /// <summary>
+    ///     DNA of the person.
+    /// </summary>
+    [ViewVariables]
+    public string? DNA;
+
+    /// <summary>
+    /// The entity that owns this record. Should always nonnull inside CharacterRecordsComponent. This field should not be accessed client side.
+    /// </summary>
+    [ViewVariables]
+    [NonSerialized]
+    public EntityUid? Owner;
+
+    public FullCharacterRecords(
+        CharacterRecords characterRecords,
+        uint? stationRecordsKey,
+        string name,
+        int age,
+        string jobTitle,
+        string jobIcon,
+        string species,
+        Gender gender,
+        Sex sex,
+        string? fingerprint,
+        string? dna,
+        EntityUid? owner = null)
+    {
+        CharacterRecords = characterRecords;
+        StationRecordsKey = stationRecordsKey;
+        Name = name;
+        Age = age;
+        JobTitle = jobTitle;
+        JobIcon = jobIcon;
+        Species = species;
+        Gender = gender;
+        Sex = sex;
+        Fingerprint = fingerprint;
+        DNA = dna;
+        Owner = owner;
+    }
+
+
+}
diff --git a/Content.Shared/_CD/Records/SharedCharacterRecordConsole.cs b/Content.Shared/_CD/Records/SharedCharacterRecordConsole.cs
new file mode 100644
index 00000000000..ccec7823e82
--- /dev/null
+++ b/Content.Shared/_CD/Records/SharedCharacterRecordConsole.cs
@@ -0,0 +1,73 @@
+using Content.Shared.Security;
+using Content.Shared.StationRecords;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._CD.Records;
+
+[Serializable, NetSerializable]
+public enum CharacterRecordConsoleKey : byte
+{
+    Key
+}
+
+[Serializable, NetSerializable]
+public enum RecordConsoleType : byte
+{
+    Security,
+    Medical,
+    Employment,
+    /// <summary>
+    /// Admin console has the functionality of all other types and has some additional admin related functionality
+    /// </summary>
+    Admin
+}
+
+[Serializable, NetSerializable]
+public sealed class CharacterRecordConsoleState : BoundUserInterfaceState
+{
+    public RecordConsoleType ConsoleType { get; set; }
+
+    /// <summary>
+    /// Character selected in the console
+    /// </summary>
+    public uint? SelectedIndex { get; set; } = null;
+
+    /// <summary>
+    /// List of names+station record keys to display in the listing
+    /// </summary>
+    public Dictionary<uint, (string, uint?)>? RecordListing { get; set; }
+
+    /// <summary>
+    /// The contents of the selected record
+    /// </summary>
+    public FullCharacterRecords? SelectedRecord { get; set; } = null;
+
+    public StationRecordsFilter? Filter { get; set; } = null;
+
+    /// <summary>
+    /// Security status of the selected record
+    /// </summary>
+    public (SecurityStatus, string?)? SelectedSecurityStatus = null;
+}
+
+[Serializable, NetSerializable]
+public sealed class CharacterRecordsConsoleFilterMsg : BoundUserInterfaceMessage
+{
+    public readonly StationRecordsFilter? Filter;
+
+    public CharacterRecordsConsoleFilterMsg(StationRecordsFilter? filter)
+    {
+        Filter = filter;
+    }
+}
+
+[Serializable, NetSerializable]
+public sealed class CharacterRecordConsoleSelectMsg : BoundUserInterfaceMessage
+{
+    public readonly uint? Index;
+
+    public CharacterRecordConsoleSelectMsg(uint? index)
+    {
+        Index = index;
+    }
+}
diff --git a/Resources/Locale/en-US/_CD/admin/admin.ftl b/Resources/Locale/en-US/_CD/admin/admin.ftl
new file mode 100644
index 00000000000..206e45699fe
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/admin/admin.ftl
@@ -0,0 +1,4 @@
+admin-player-actions-window-cd-record-purge = Modify Character Records
+cd-actions-admin-modify-records = Modify Character Records
+cd-actions-admin-modify-reset = Reset Records
+cd-actions-admin-modify-del-entry = Delete Entry
diff --git a/Resources/Locale/en-US/_CD/guidebook/guides.ftl b/Resources/Locale/en-US/_CD/guidebook/guides.ftl
new file mode 100644
index 00000000000..9bdc746bd3a
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/guidebook/guides.ftl
@@ -0,0 +1 @@
+guide-entry-cd-records = Character Records
diff --git a/Resources/Locale/en-US/_CD/records/corrections.ftl b/Resources/Locale/en-US/_CD/records/corrections.ftl
new file mode 100644
index 00000000000..16349c7e715
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/records/corrections.ftl
@@ -0,0 +1,5 @@
+ent-CriminalRecordsComputerCircuitboard = security records computer board
+    .desc = A computer printed circuit board for a security records computer.
+
+ent-StationRecordsComputerCircuitboard = employment records computer board
+    .desc = A computer printed circuit board for a employment records computer.
diff --git a/Resources/Locale/en-US/_CD/records/editor.ftl b/Resources/Locale/en-US/_CD/records/editor.ftl
new file mode 100644
index 00000000000..57181c0b7a8
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/records/editor.ftl
@@ -0,0 +1,36 @@
+# Records editor
+humanoid-profile-editor-cd-records-tab = Records
+
+# General
+humanoid-profile-editor-cd-records-height = Height (cm):
+humanoid-profile-editor-cd-records-weight = Weight (kg):
+humanoid-profile-editor-cd-records-contact-name = Emergency Contact:
+
+# Employment
+humanoid-profile-editor-cd-records-employment = Employment
+humanoid-profile-editor-cd-records-work-authorization = Work Authorization:
+
+# Security
+humanoid-profile-editor-cd-records-identifying-features = Identifying Features:
+
+# Medical
+humanoid-profile-editor-cd-records-allergies = Allergies:
+humanoid-profile-editor-cd-records-drug-allergies = Drug Allergies:
+humanoid-profile-editor-cd-records-postmortem = Postmortem Instructions:
+
+# Entries
+humanoid-profile-editor-cd-records-add-entry = Add Entry
+humanoid-profile-editor-cd-records-edit-entry = Edit Entry
+humanoid-profile-editor-cd-records-view-entry = View Entry
+humanoid-profile-editor-cd-records-remove-entry = Remove Entry
+humanoid-profile-editor-cd-records-up = Up
+humanoid-profile-editor-cd-records-down = Down
+
+cd-records-entry-edit-popup-title = View/Edit Entry
+cd-records-entry-edit-popup-save = Save
+cd-records-entry-default-title = Untitled Entry
+
+cd-records-entry-edit-popup-title-placeholder = Entry Title
+cd-records-entry-edit-popup-involved-placeholder = Involved Staff
+cd-records-entry-edit-popup-description-placeholder = Description
+
diff --git a/Resources/Locale/en-US/_CD/records/viewer.ftl b/Resources/Locale/en-US/_CD/records/viewer.ftl
new file mode 100644
index 00000000000..830f86decde
--- /dev/null
+++ b/Resources/Locale/en-US/_CD/records/viewer.ftl
@@ -0,0 +1,26 @@
+cd-character-records-viewer-title-employ = Employment Records
+cd-character-records-viewer-title-sec = Security Records
+cd-character-records-viewer-title-med = Medical Records
+
+cd-record-viewer-empty-state = Cannot fetch records.
+cd-record-viewer-no-record-selected = Please select record.
+
+cd-character-records-viewer-record-age = Age:
+cd-character-records-viewer-record-job = Job:
+cd-character-records-viewer-record-gender = Gender:
+cd-character-records-viewer-record-species = Species:
+
+cd-character-records-viewer-record-sec-fingerprint = Fingerprint:
+cd-character-records-viewer-record-sec-dna = DNA:
+
+cd-character-records-viewer-unknown = ERROR UNKNOWN
+
+cd-character-records-viewer-record-med-sex = Sex:
+
+cd-character-records-viewer-view-entry = View
+cd-records-entry-view-popup-title = View Entry
+
+cd-character-records-entry-view-title = Title:
+cd-character-records-entry-view-involved = Involved:
+
+cd-character-records-viewer-setwanted-placeholder = Reason
diff --git a/Resources/Locale/en-US/preferences/ui/humanoid-profile-editor.ftl b/Resources/Locale/en-US/preferences/ui/humanoid-profile-editor.ftl
index b1a695dbedc..2361a75499a 100644
--- a/Resources/Locale/en-US/preferences/ui/humanoid-profile-editor.ftl
+++ b/Resources/Locale/en-US/preferences/ui/humanoid-profile-editor.ftl
@@ -1,4 +1,5 @@
 humanoid-profile-editor-randomize-everything-button = Randomize everything
+humanoid-profile-editor-reset-height-button = Reset
 humanoid-profile-editor-name-label = Name:
 humanoid-profile-editor-name-random-button = Randomize
 humanoid-profile-editor-appearance-tab = Appearance
@@ -10,6 +11,7 @@ humanoid-profile-editor-sex-female-text = Female
 humanoid-profile-editor-sex-unsexed-text = None
 humanoid-profile-editor-age-label = Age:
 humanoid-profile-editor-skin-color-label = Skin color:
+humanoid-profile-editor-height-label = Height:
 humanoid-profile-editor-species-label = Species:
 humanoid-profile-editor-pronouns-label = Pronouns:
 humanoid-profile-editor-pronouns-male-text = He / Him
diff --git a/Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml b/Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml
index 80e87d3670c..a36d7d57c8b 100644
--- a/Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml
+++ b/Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml
@@ -53,6 +53,8 @@
       - key: enum.GeneralStationRecordConsoleKey.Key
         # who the fuck named this bruh
         type: GeneralStationRecordConsoleBoundUserInterface
+      - key: enum.CharacterRecordConsoleKey.Key
+        type: CharacterRecordConsoleBoundUserInterface
   - type: IntrinsicUI
     uis:
       - key: enum.SolarControlConsoleUiKey.Key
@@ -65,8 +67,8 @@
         toggleAction: ActionAGhostShowCargo
       - key: enum.CrewMonitoringUIKey.Key
         toggleAction: ActionAGhostShowCrewMonitoring
-      - key: enum.GeneralStationRecordConsoleKey.Key
-        toggleAction: ActionAGhostShowStationRecords
+      - key: enum.CharacterRecordConsoleKey.Key
+        toggleAction: ActionAGhostShowCharacterRecords
   - type: SolarControlConsole # look ma i AM the computer!
   - type: CommunicationsConsole
     title: comms-console-announcement-title-centcom
@@ -97,6 +99,10 @@
   - type: InventorySlots
   - type: Loadout
     prototypes: [ MobAghostGear ]
+  - type: CharacterRecordConsole
+    consoleType: Admin
+    # Needed for security records console functionality
+  - type: CriminalRecordsConsole
 
 - type: entity
   id: ActionAGhostShowSolar
@@ -175,3 +181,17 @@
     keywords: [ "AI", "console", "interface" ]
     priority: -10
     event: !type:ToggleIntrinsicUIEvent { key: enum.GeneralStationRecordConsoleKey.Key }
+
+- type: entity
+  id: ActionAGhostShowCharacterRecords
+  name: Character Records Interface
+  description: View all of the character records
+  noSpawn: true
+  components:
+  - type: InstantAction
+    icon: { sprite: Structures/Machines/parts.rsi, state: box_0 }
+    iconOn: Structures/Machines/parts.rsi/box_2.png
+    keywords: [ "AI", "console", "interface" ]
+    priority: -10
+    event: !type:ToggleIntrinsicUIEvent { key: enum.CharacterRecordConsoleKey.Key }
+
diff --git a/Resources/Prototypes/Entities/Mobs/Species/dwarf.yml b/Resources/Prototypes/Entities/Mobs/Species/dwarf.yml
index d2c511ce425..c775bcf25a9 100644
--- a/Resources/Prototypes/Entities/Mobs/Species/dwarf.yml
+++ b/Resources/Prototypes/Entities/Mobs/Species/dwarf.yml
@@ -21,7 +21,6 @@
   - type: Sprite
     noRot: true
     drawdepth: Mobs
-    scale: 1, 0.8
   - type: Body
     prototype: Dwarf
     requiredLegs: 2
@@ -57,6 +56,3 @@
   parent: BaseSpeciesDummy
   id: MobDwarfDummy
   noSpawn: true
-  components:
-  - type: Sprite
-    scale: 1, 0.8
diff --git a/Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml b/Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml
index b9e75d9df86..d866123f9c1 100644
--- a/Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml
+++ b/Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml
@@ -280,20 +280,24 @@
     color: "#1f8c28"
   - type: Computer
     board: MedicalRecordsComputerCircuitboard
+  - type: CharacterRecordConsole
+    consoleType: Medical
+  - type: UserInterface
+    interfaces:
+      - key: enum.CharacterRecordConsoleKey.Key
+        type: CharacterRecordConsoleBoundUserInterface
+  - type: ActivatableUI
+    key: enum.CharacterRecordConsoleKey.Key
 
 - type: entity
   parent: BaseComputer
   id: ComputerCriminalRecords
-  name: criminal records computer
-  description: This can be used to check criminal records. Only security can modify them.
+  name: security records computer
+  description: This can be used to access security records.
   components:
+    # We need to have both a CriminalRecordsConsole and CharacterRecordConsole
+    # component to be able to set wanted status.
   - type: CriminalRecordsConsole
-  - type: UserInterface
-    interfaces:
-    - key: enum.CriminalRecordsConsoleKey.Key
-      type: CriminalRecordsConsoleBoundUserInterface
-  - type: ActivatableUI
-    key: enum.CriminalRecordsConsoleKey.Key
   - type: Sprite
     layers:
     - map: ["computerLayerBody"]
@@ -312,23 +316,21 @@
     board: CriminalRecordsComputerCircuitboard
   - type: AccessReader
     access: [["Security"]]
-  - type: GuideHelp
-    guides:
-    - CriminalRecords
+  - type: CharacterRecordConsole
+    consoleType: Security
+  - type: UserInterface
+    interfaces:
+      - key: enum.CharacterRecordConsoleKey.Key
+        type: CharacterRecordConsoleBoundUserInterface
+  - type: ActivatableUI
+    key: enum.CharacterRecordConsoleKey.Key
 
 - type: entity
   parent: BaseComputer
   id: ComputerStationRecords
-  name: station records computer
-  description: This can be used to check station records.
+  name: employment records computer
+  description: This can be used to check employment records.
   components:
-  - type: GeneralStationRecordConsole
-  - type: UserInterface
-    interfaces:
-      - key: enum.GeneralStationRecordConsoleKey.Key
-        type: GeneralStationRecordConsoleBoundUserInterface
-  - type: ActivatableUI
-    key: enum.GeneralStationRecordConsoleKey.Key
   - type: PointLight
     radius: 1.5
     energy: 1.6
@@ -338,6 +340,14 @@
   - type: GuideHelp
     guides:
     - Forensics
+  - type: CharacterRecordConsole
+    consoleType: Employment
+  - type: UserInterface
+    interfaces:
+      - key: enum.CharacterRecordConsoleKey.Key
+        type: CharacterRecordConsoleBoundUserInterface
+  - type: ActivatableUI
+    key: enum.CharacterRecordConsoleKey.Key
 
 - type: entity
   parent: BaseComputer
diff --git a/Resources/Prototypes/Guidebook/ss14.yml b/Resources/Prototypes/Guidebook/ss14.yml
index c1017fefcae..2e3eee81ee1 100644
--- a/Resources/Prototypes/Guidebook/ss14.yml
+++ b/Resources/Prototypes/Guidebook/ss14.yml
@@ -10,6 +10,8 @@
   - Antagonists
   - Species
   - Writing
+  - Cryosleep
+  - Records
   - Glossary
 
 - type: guideEntry
@@ -22,4 +24,12 @@
   name: guide-entry-glossary
   text: "/ServerInfo/Guidebook/Glossary.xml"
 
+- type: guideEntry
+  id: Cryosleep
+  name: guide-entry-cryosleep
+  text: "/ServerInfo/Guidebook/Cryosleep.xml"
 
+- type: guideEntry
+  id: Records
+  name: guide-entry-cd-records
+  text: "/ServerInfo/Guidebook/_CD/Records.xml"
diff --git a/Resources/Prototypes/Species/dwarf.yml b/Resources/Prototypes/Species/dwarf.yml
index 86743ca2d66..4b68406790f 100644
--- a/Resources/Prototypes/Species/dwarf.yml
+++ b/Resources/Prototypes/Species/dwarf.yml
@@ -7,3 +7,8 @@
   markingLimits: MobHumanMarkingLimits
   dollPrototype: MobDwarfDummy
   skinColoration: HumanToned
+  defaultHeight: 0.8
+  minHeight: 0.6
+  maxHeight: 0.8
+  scaleHeight: false
+  scaleWidth: true
diff --git a/Resources/ServerInfo/Guidebook/_CD/Records.xml b/Resources/ServerInfo/Guidebook/_CD/Records.xml
new file mode 100644
index 00000000000..aa7020f3dcd
--- /dev/null
+++ b/Resources/ServerInfo/Guidebook/_CD/Records.xml
@@ -0,0 +1,40 @@
+<Document>
+
+## Character Records
+
+You can create records for you characters in the records tab of the character
+creator. Just simply fill in the values and save. Entries should typically be
+written from the perspective of a CentCom official.
+
+## Employment Entries
+
+Employment Entries should include your characters education, previous jobs, and
+anything that you think NanoTrasen would log about your characters past that is
+not security related.
+
+## Medical Entries
+
+Medical Entries should include anything a doctor should know before treating
+your character, major surgeries, prescriptions, and any psychological evaluations.
+
+## Security Entries
+
+Security Entries should include any major arrests/incidents your character has
+had in their past or while working with NanoTrasen. Do not log minor incidents.
+
+## Accessing Records
+You can access the records of your crewmates in game from their respective consoles.
+
+<Box>
+<GuideEntityEmbed Entity="ComputerMedicalRecords" Caption="Medical"/>
+<GuideEntityEmbed Entity="ComputerCriminalRecords" Caption="Security"/>
+<GuideEntityEmbed Entity="ComputerStationRecords" Caption="Employment"/>
+</Box>
+
+It is currently not possible to create new records in game. This is something
+that will be added in the future. If there is something that occurs in the round
+that you think is relevant for a record entry, it is on you to write it at the
+moment. Keep in mind that records should typically be written from the
+perspective of some CentCom official.
+
+</Document>