package BaseStats
using RTDB

RegenStat : Stat
{
	min = -100;
	max = 100;
}

StaminaRegenEnabled : StatFlag
{
	enumName = "StaminaRegenEnabled";
}

StaminaRegenDelayOnChange : StatFlag
{
	enumName = "StaminaRegenDelayOnChange";
}

StaminaRegenRate : RegenStat
{
	enumName = "StaminaRegenRate";
	localizedName = "LocKey#49468";
	min = -100;
	max = 125;
}

StaminaRegenRateBase : RegenStat
{
	enumName = "StaminaRegenRateBase";
	min = -100;
	max = 125;
}

StaminaRegenRateAdd : RegenStat
{
	enumName = "StaminaRegenRateAdd";
}

StaminaRegenRateMult : RegenStat
{
	enumName = "StaminaRegenRateMult";
}

StaminaRegenStartThreshold : RegenStat
{
	enumName = "StaminaRegenStartThreshold";
}

StaminaRegenEndThrehold : RegenStat
{
	enumName = "StaminaRegenEndThrehold";
}

StaminaRegenStartDelay : RegenStat
{
	enumName = "StaminaRegenStartDelay";
}

StaminaDecayEnabled : StatFlag
{
	enumName = "StaminaDecayEnabled";
}

StaminaDecayStartThreshold : RegenStat
{
	enumName = "StaminaDecayStartThreshold";
}

StaminaDecayEndThrehold : RegenStat
{
	enumName = "StaminaDecayEndThrehold";
}

StaminaDecayRate : RegenStat
{
	enumName = "StaminaDecayRate";
}

StaminaDecayStartDelay : RegenStat
{
	enumName = "StaminaDecayStartDelay";
}

StaminaSprintDecayRate : RegenStat
{
	enumName = "StaminaSprintDecayRate";
}

StaminaDecayDelayOnChange : RegenStat
{
	enumName = "StaminaDecayDelayOnChange";
}

StaminaAimingCost : RegenStat
{
	enumName = "StaminaAimingCost";
	enumComment = "";
}

OvershieldDecayEnabled : StatFlag
{
	enumName = "OvershieldDecayEnabled";
}

OvershieldDelayOnChange : StatFlag
{
	enumName = "OvershieldDelayOnChange";
}

OvershieldDecayStartThreshold : RegenStat
{
	enumName = "OvershieldDecayStartThreshold";
}

OvershieldDecayEndThrehold : RegenStat
{
	enumName = "OvershieldDecayEndThrehold";
}

OvershieldDecayRate : RegenStat
{
	enumName = "OvershieldDecayRate";
	min = 0;
	max = 200;
}

OvershieldDecayStartDelay : RegenStat
{
	enumName = "OvershieldDecayStartDelay";
}

OvershieldDecayDelayOnChange : StatFlag
{
	enumName = "OvershieldDecayDelayOnChange";
}

OvershieldGainedToHealAmountMultiplier : RegenStat
{
	enumName = "OvershieldGainedToHealAmountMultiplier";
}

HealthInCombatRegenEnabled : StatFlag
{
	max = 2;
	enumName = "HealthInCombatRegenEnabled";
}

HealthInCombatRegenDelayOnChange : StatFlag
{
	enumName = "HealthInCombatRegenDelayOnChange";
}

HealthInCombatStartDelay : RegenStat
{
	enumName = "HealthInCombatStartDelay";
}

HealthInCombatRegenRate : RegenStat
{
	enumName = "HealthInCombatRegenRate";
	localizedName = "LocKey#49467";
}

HealthInCombatRegenRateBase : RegenStat
{
	enumName = "HealthInCombatRegenRateBase";
}

HealthInCombatRegenRateAdd : RegenStat
{
	enumName = "HealthInCombatRegenRateAdd";
}

HealthInCombatRegenRateMult : RegenStat
{
	enumName = "HealthInCombatRegenRateMult";
}

HealthInCombatRegenStartThreshold : RegenStat
{
	min = 0.00000000001;
	enumName = "HealthInCombatRegenStartThreshold";
}

HealthInCombatRegenEndThreshold : RegenStat
{
	enumName = "HealthInCombatRegenEndThreshold";
}

HealthOutOfCombatRegenEnabled : StatFlag
{
	enumName = "HealthOutOfCombatRegenEnabled";
}

HealthOutOfCombatRegenDelayOnChange : StatFlag
{
	max = 60;
	enumName = "HealthOutOfCombatRegenDelayOnChange";
}

HealthOutOfCombatRegenRate : RegenStat
{
	enumName = "HealthOutOfCombatRegenRate";
	localizedName = "LocKey#49466";
}

HealthOutOfCombatRegenRateBase : RegenStat
{
	enumName = "HealthOutOfCombatRegenRateBase";
}

HealthOutOfCombatRegenRateAdd : RegenStat
{
	enumName = "HealthOutOfCombatRegenRateAdd";
}

HealthOutOfCombatRegenRateMult : RegenStat
{
	enumName = "HealthOutOfCombatRegenRateMult";
}

HealthOutOfCombatRegenStartThreshold : RegenStat
{
	min = 0.0000000001;
	enumName = "HealthOutOfCombatRegenStartThreshold";
}

HealthOutOfCombatRegenEndThreshold : RegenStat
{
	enumName = "HealthOutOfCombatRegenEndThreshold";
}

HealthGeneralRegenRateAdd : RegenStat
{
	enumName = "HealthGeneralRegenRateAdd";
	localizedName = "LocKey#81264";
	flags = 
	[
		"EquipOnPlayer"
	];
	decimalPlaces = 1;
	displayPlus = true;
	improvementRelation = "ImprovementRelation.Direct";
}

HealthGeneralRegenRateMult : RegenStat
{
	enumName = "HealthGeneralRegenRateMult";
	localizedName = "LocKey#81264";
	flags = 
	[
		"EquipOnPlayer"
	];
	decimalPlaces = 1;
	displayPlus = true;
	displayPercent = true;
	multiplyBy100InText = true;
	improvementRelation = "ImprovementRelation.Direct";
}

MemoryRegenEnabled : StatFlag
{
	enumName = "MemoryRegenEnabled";
}

MemoryRegenDelayOnChange : StatFlag
{
	enumName = "MemoryRegenDelayOnChange";
}

MemoryStartDelay : RegenStat
{
	enumName = "MemoryStartDelay";
}

MemoryRegenRate : RegenStat
{
	enumName = "MemoryRegenRate";
	localizedName = "LocKey#49469";
}

MemoryRegenRateBase : RegenStat
{
	enumName = "MemoryRegenRateBase";
}

MemoryRegenRateAdd : RegenStat
{
	enumName = "MemoryRegenRateAdd";
}

MemoryRegenRateMult : RegenStat
{
	enumName = "MemoryRegenRateMult";
}

MemoryRegenStartThreshold : RegenStat
{
	enumName = "MemoryRegenStartThreshold";
}

MemoryRegenEndThreshold : RegenStat
{
	enumName = "MemoryRegenEndThreshold";
}

HealingItemsRechargeDuration : RegenStat
{
	enumName = "HealingItemsRechargeDuration";
}

HealingItemsChargesRegenEnabled : StatFlag
{
	enumName = "HealingItemsChargesRegenEnabled";
}

HealingItemsChargesRegenBegins : RegenStat
{
	enumName = "HealingItemsChargesRegenBegins";
}

HealingItemsChargesRegenRate : RegenStat
{
	enumName = "HealingItemsChargesRegenRate";
	decimalPlaces = 1;
	displayPercent = true;
	displayPlus = true;
	multiplyBy100InText = true;
	localizedName = "LocKey#91479";
	improvementRelation = "ImprovementRelation.Direct";
}

HealingItemsChargesRegenMult : HealingItemsChargesRegenRate
{
	enumName = "HealingItemsChargesRegenMult";
	flags = 
	[
		"EquipOnPlayer"
	];
}

HealingItemsChargesRegenEnds : RegenStat
{
	enumName = "HealingItemsChargesRegenEnds";
}

HealingItemsChargesDecayStartDelay : RegenStat
{
	enumName = "HealingItemsChargesDecayStartDelay";
}

HealingItemsChargesDelayOnChange : RegenStat
{
	enumName = "HealingItemsChargesDelayOnChange";
}

GrenadesRechargeDuration : RegenStat
{
	enumName = "GrenadesRechargeDuration";
}

GrenadesChargesRegenEnabled : StatFlag
{
	enumName = "GrenadesChargesRegenEnabled";
}

GrenadesChargesRegenBegins : RegenStat
{
	enumName = "GrenadesChargesRegenBegins";
}

GrenadesChargesRegenRate : RegenStat
{
	enumName = "GrenadesChargesRegenRate";
	decimalPlaces = 1;
	displayPercent = true;
	displayPlus = true;
	multiplyBy100InText = true;
	localizedName = "LocKey#91480";
	improvementRelation = "ImprovementRelation.Direct";
}

GrenadesChargesRegenMult : GrenadesChargesRegenRate
{
	enumName = "GrenadesChargesRegenMult";
	flags = 
	[
		"EquipOnPlayer"
	];
}

GrenadesChargesRegenEnds : RegenStat
{
	enumName = "GrenadesChargesRegenEnds";
}

GrenadesChargesDecayStartDelay : RegenStat
{
	enumName = "GrenadesChargesDecayStartDelay";
}

GrenadesChargesDelayOnChange : RegenStat
{
	enumName = "GrenadesChargesDelayOnChange";
}

VehicleMissileLauncherRechargeDuration : RegenStat
{
	enumName = "VehicleMissileLauncherRechargeDuration";
}

VehicleMissileLauncherRegenEnabled : StatFlag
{
	enumName = "VehicleMissileLauncherRegenEnabled";
}

VehicleMissileLauncherChargesRegenBegins : RegenStat
{
	enumName = "VehicleMissileLauncherChargesRegenBegins";
}

VehicleMissileLauncherChargesRegenEnds : RegenStat
{
	enumName = "VehicleMissileLauncherChargesRegenEnds";
}

VehicleMissileLauncherChargesRegenRate : RegenStat
{
	enumName = "VehicleMissileLauncherChargesRegenRate";
	multiplyBy100InText = true;
}

VehicleMissileLauncherChargesRegenStartDelay : RegenStat
{
	enumName = "VehicleMissileLauncherChargesRegenStartDelay";
}

VehicleMissileLauncherChargesRegenDelayOnChange : RegenStat
{
	enumName = "VehicleMissileLauncherChargesRegenDelayOnChange";
}

InjectorHealingEnabled : StatFlag
{
	enumName = "InjectorHealingRegenEnabled";
}

InjectorHealingRegenBegins : RegenStat
{
	enumName = "InjectorHealingRegenBegins";
}

InjectorHealingRegenEnds : RegenStat
{
	enumName = "InjectorHealingRegenEnds";
}

InjectorHealingDecayStartDelay : RegenStat
{
	enumName = "InjectorHealingDecayStartDelay";
}

InjectorHealingDelayOnChange : RegenStat
{
	enumName = "InjectorHealingDelayOnChange";
}

InhalerBaseHealing : RegenStat
{
	min = 0;
	max = 200;
	enumName = "InhalerBaseHealing";
}

InjectorBaseHealing : RegenStat
{
	min = 0;
	max = 200;
	enumName = "InjectorBaseHealing";
}

InjectorBaseOverTheTimeHealing : RegenStat
{
	min = 0;
	max = 30;
	enumName = "InjectorBaseOverTheTimeHealing";
}

OpticalCamoRechargeDuration : Stat
{
	enumName = "OpticalCamoRechargeDuration";
	min = 0;
	max = 999;
}

OpticalCamoChargesRegenEnabled : StatFlag
{
	enumName = "OpticalCamoChargesRegenEnabled";
}

OpticalCamoChargesRegenBegins : RegenStat
{
	enumName = "OpticalCamoChargesRegenBegins";
}

OpticalCamoChargesRegenRate : RegenStat
{
	enumName = "OpticalCamoChargesRegenRate";
}

OpticalCamoChargesDecayRate : RegenStat
{
	enumName = "OpticalCamoChargesDecayRate";
}

OpticalCamoChargesDecayRateMult : RegenStat
{
	enumName = "OpticalCamoChargesDecayRateMult";
}

OpticalCamoChargesRegenEnds : RegenStat
{
	enumName = "OpticalCamoChargesRegenEnds";
}

OpticalCamoChargesDecayStartDelay : RegenStat
{
	enumName = "OpticalCamoChargesDecayStartDelay";
}

OpticalCamoChargesDelayOnChange : RegenStat
{
	enumName = "OpticalCamoChargesDelayOnChange";
}

OpticalCamoEmptyStat : RegenStat
{
	enumName = "OpticalCamoEmptyStat";
}

HasOpticalCamoRare : StatFlag
{
	enumName = "HasOpticalCamoRare";
}

HasOpticalCamoEpic : StatFlag
{
	enumName = "HasOpticalCamoEpic";
}

HasOpticalCamoLegendary : StatFlag
{
	enumName = "HasOpticalCamoLegendary";
}

OpticalCamoDuration : RegenStat
{
	enumName = "OpticalCamoDuration";
}

CWMaskRechargeDuration : Stat
{
	enumName = "CWMaskRechargeDuration";
	min = 0;
	max = 9999;
	flags = 
	[
		"EquipOnPlayer"
	];
}

CWMaskChargesRegenEnabled : StatFlag
{
	enumName = "CWMaskChargesRegenEnabled";
}

CWMaskChargesRegenBegins : RegenStat
{
	enumName = "CWMaskChargesRegenBegins";
}

CWMaskChargesRegenRate : RegenStat
{
	enumName = "CWMaskChargesRegenRate";
}

CWMaskChargesRegenEnds : RegenStat
{
	enumName = "CWMaskChargesRegenEnds";
}

CWMaskChargesDecayStartDelay : RegenStat
{
	enumName = "CWMaskChargesDecayStartDelay";
}

CWMaskChargesDelayOnChange : RegenStat
{
	enumName = "CWMaskChargesDelayOnChange";
}

ProjectileLauncherRechargeDuration : RegenStat
{
	enumName = "ProjectileLauncherRechargeDuration";
	min = 0;
	max = 999;
}

ProjectileLauncherChargesRegenEnabled : StatFlag
{
	enumName = "ProjectileLauncherRegenEnabled";
}

ProjectileLauncherChargesRegenBegins : RegenStat
{
	enumName = "ProjectileLauncherChargesRegenBegins";
}

ProjectileLauncherChargesRegenRate : RegenStat
{
	enumName = "ProjectileLauncherChargesRegenRate";
}

ProjectileLauncherChargesRegenMult : RegenStat
{
	enumName = "ProjectileLauncherChargesRegenMult";
}

ProjectileLauncherChargesRegenEnds : RegenStat
{
	enumName = "ProjectileLauncherChargesRegenEnds";
}

ProjectileLauncherChargesDecayStartDelay : RegenStat
{
	enumName = "ProjectileLauncherChargesDecayStartDelay";
}

ProjectileLauncherChargesDelayOnChange : RegenStat
{
	enumName = "ProjectileLauncherChargesDelayOnChange";
}

BerserkRechargeDuration : Stat
{
	enumName = "BerserkRechargeDuration";
	min = 0;
	max = 999;
}

BerserkChargesRegenEnabled : StatFlag
{
	enumName = "BerserkChargesRegenEnabled";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesRegenBegins : RegenStat
{
	enumName = "BerserkChargesRegenBegins";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesRegenRate : RegenStat
{
	enumName = "BerserkChargesRegenRate";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesRegenEnds : RegenStat
{
	enumName = "BerserkChargesRegenEnds";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesDecayEnabled : RegenStat
{
	enumName = "BerserkChargesDecayEnabled";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesDecayBegins : RegenStat
{
	enumName = "BerserkChargesDecayBegins";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesDecayRate : RegenStat
{
	enumName = "BerserkChargesDecayRate";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesDecayRateMult : RegenStat
{
	enumName = "BerserkChargesDecayRateMult";
}

BerserkChargesDecayEnds : RegenStat
{
	enumName = "BerserkChargesDecayEnds";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesDecayStartDelay : RegenStat
{
	enumName = "BerserkChargesDecayStartDelay";
	flags += 
	[
		"EquipOnPlayer"
	];
}

BerserkChargesDelayOnChange : RegenStat
{
	enumName = "BerserkChargesDelayOnChange";
	flags += 
	[
		"EquipOnPlayer"
	];
}

SandevistanRechargeDuration : Stat
{
	enumName = "SandevistanRechargeDuration";
	min = 0;
	max = 999;
}

SandevistanChargesRegenEnabled : StatFlag
{
	enumName = "SandevistanChargesRegenEnabled";
}

SandevistanChargesRegenBegins : RegenStat
{
	enumName = "SandevistanChargesRegenBegins";
}

TimeDilationSandevistanRechargeDuration : RegenStat
{
	enumName = "TimeDilationSandevistanRechargeDuration";
	flags += 
	[
		"EquipOnPlayer"
	];
}

SandevistanChargesRegenEnds : RegenStat
{
	enumName = "SandevistanChargesRegenEnds";
}

SandevistanChargesRegenStartDelay : RegenStat
{
	enumName = "SandevistanChargesRegenStartDelay";
}

SandevistanChargesRegenDelayOnChange : RegenStat
{
	enumName = "SandevistanChargesRegenDelayOnChange";
}

SandevistanChargesDecayStartDelay : RegenStat
{
	enumName = "SandevistanChargesDecayStartDelay";
}

PlayerSandevistanChargesDecayEnabled : StatFlag
{
	enumName = "PlayerSandevistanChargesDecayEnabled";
}

PlayerCorruptedSandevistanChargesDecayEnabled : StatFlag
{
	enumName = "PlayerCorruptedSandevistanChargesDecayEnabled";
}

SandevistanChargesDecayDelayOnChange : StatFlag
{
	enumName = "SandevistanChargesDecayDelayOnChange";
}

PlayerSandevistanChargesDecayPerSecond : RegenStat
{
	enumName = "PlayerSandevistanChargesDecayPerSecond";
	flags += 
	[
		"EquipOnPlayer"
	];
}

PlayerSandevistanChargesEmptyStat : Stat
{
	enumName = "PlayerSandevistanChargesEmptyStat";
	enumComment = "A stat used for constant regen modifiers";
}

CyberdeckOverclockDuration : Stat
{
	enumName = "CyberdeckOverclockDuration";
	min = 0;
	max = 999;
}

CyberdeckOverclockStatValue : RegenStat
{
	enumName = "CyberdeckOverclockStatValue";
}

CyberdeckOverclockCooldown : RegenStat
{
	enumName = "CyberdeckOverclockCooldown";
}

CyberdeckOverclockRegenEnabled : StatFlag
{
	enumName = "CyberdeckOverclockRegenEnabled";
}

CyberdeckOverclockRegenBegins : RegenStat
{
	enumName = "CyberdeckOverclockRegenBegins";
}

CyberdeckOverclockRegenRate : RegenStat
{
	enumName = "CyberdeckOverclockRegenRate";
}

CyberdeckOverclockRegenEnds : RegenStat
{
	enumName = "CyberdeckOverclockRegenEnds";
}

CyberdeckOverclockDecayStartDelay : RegenStat
{
	enumName = "CyberdeckOverclockDecayStartDelay";
}

CyberdeckOverclockDelayOnChange : RegenStat
{
	enumName = "CyberdeckOverclockDelayOnChange";
}

CyberdeckOverclockEmptyStat : Stat
{
	enumName = "CyberdeckOverclockEmptyStat";
	enumComment = "A stat used for constant regen modifiers";
}

CyberdeckOverclockDecayRate : RegenStat
{
	enumName = "CyberdeckOverclockDecayRate";
}

InVehicleDamageTakenPercent : Stat
{
	enumName = "InVehicleDamageTakenPercent";
	enumComment = "Percentage of damage taken by the player while inside a vehicle";
	improvementRelation = "ImprovementRelation.Inverse";
}

OnBikeDamageTakenPercent : Stat
{
	enumName = "OnBikeDamageTakenPercent";
	enumComment = "Percentage of damage taken by the player while on a bike, actual damage taken is scaled from [1, OnBikeDamageTakenPercent] based on the player's speed";
	improvementRelation = "ImprovementRelation.Inverse";
}

OnBikeDamageTakenPercentMinSpeed : Stat
{
	enumName = "OnBikeDamageTakenPercentMinSpeed";
	enumComment = "Minimum speed (m/s) to start linearly applying OnBikeDamageTakenPercent";
}

OnBikeDamageTakenPercentMaxSpeed : Stat
{
	enumName = "OnBikeDamageTakenPercentMaxSpeed";
	enumComment = "Speed (m/s) at which the entire OnBikeDamageTakenPercent is applied";
}

EdgerunnerHealthReduction : Stat
{
	enumName = "EdgerunnerHealthReduction";
	enumComment = "By what percentage does the edgerunner perk reduce your health";
}

ArmorEffectivenessMultiplier : Stat
{
	enumName = "ArmorEffectivenessMultiplier";
}

ExplosionResistance : Stat
{
	enumName = "ExplosionResistance";
	enumComment = "Resistance against explosive damage";
	localizedName = "LocKey#81885";
	flags = 
	[
		"EquipOnPlayer"
	];
	decimalPlaces = 1;
	displayPlus = true;
	displayPercent = true;
}

MeleeResistance : Stat
{
	enumName = "MeleeResistance";
	enumComment = "Resistance against melee damage";
	localizedName = "LocKey#81886";
	flags = 
	[
		"EquipOnPlayer"
	];
	decimalPlaces = 1;
	displayPlus = true;
	displayPercent = true;
}

BossResistance : Stat
{
	enumName = "BossResistance";
	enumComment = "Resistance against boss damage";
	localizedName = "LocKey#81887";
	flags = 
	[
		"EquipOnPlayer"
	];
	decimalPlaces = 1;
	displayPlus = true;
}

QuickhackResistance : Stat
{
	enumName = "QuickhackResistance";
	enumComment = "Resistance against quickhack damage";
	localizedName = "LocKey#81892";
	flags = 
	[
		"EquipOnPlayer"
	];
	decimalPlaces = 1;
	displayPlus = true;
}

MechResistance : Stat
{
	enumName = "MechResistance";
	enumComment = "Resistance against damage from mechs";
	localizedName = "LocKey#81981";
	flags = 
	[
		"EquipOnPlayer"
	];
	decimalPlaces = 1;
	displayPlus = true;
}

DamageOverTimeResistance : Stat
{
	enumName = "DamageOverTimeResistance";
	enumComment = "Resistance against damage over time effects";
	localizedName = "LocKey#91465";
	flags = 
	[
		"EquipOnPlayer"
	];
	decimalPlaces = 1;
	displayPlus = true;
	displayPercent = true;
}

PermanentHealthBonus : Stat
{
	enumName = "HealthBonusBlackmarket";
	enumComment = "Permanent health boost from blackmarket food";
}

PermanentStaminaRegenBonus : Stat
{
	enumName = "StaminaRegenBonusBlackmarket";
	enumComment = "Permanent stamina regen boost from blackmarket food";
}

PermanentMemoryRegenBonus : Stat
{
	enumName = "MemoryRegenBonusBlackmarket";
	enumComment = "Permanent Memory regen boost from blackmarket food";
}

