datalib

type AbilityComponent struct {
	SpawnAbilities [4]SpawnAbility // Ability to play if spawned with the corresponding job (AiJob_Count)
}

type ActionSlideMovementInfo struct {
	SlideFlatDuration     float32 `json:"slide_flat_duration"`     // The exit duration when sliding on flat ground
	SlideFlatSpeed        float32 `json:"slide_flat_speed"`        // The speed when sliding on flat ground
	SlideUphillDuration   float32 `json:"slide_uphill_duration"`   // The exit duration when sliding into max uphill slopes
	SlideUphillSpeed      float32 `json:"slide_uphill_speed"`      // The speed when sliding into uphill slopes
	SlideDownhillDuration float32 `json:"slide_downhill_duration"` // The exit duration when sliding down max downhill slopes
	SlideDownhillSpeed    float32 `json:"slide_downhill_speed"`    // The speed when sliding down downhill slopes
}

type ActiveEffectSetting struct {
	ID           stingray.ThinHash // [string]Identifier for this effect, used when playing effects from behavior
	StartEnabled uint8             // [bool]If true, effect is triggered on spawn

	Effect EffectSetting // Particle effect to play while the entity lives and is destroyed on death.
	// contains filtered or unexported fields
}

type AnimationComponent struct {
	MergeOptions                 AnimationMergeOptions // Animation merge options (or animation sharing options).
	Variables                    [8]AnimationVariable  // Information about any variables to be set when spawning the animated entity.
	HotjoinSyncAnimationTime     uint8                 // [bool]If set, the time into the current animation is also synced. Useful for long animations, such as the dropship sequence.
	IgnoreInvisibileUnitsForLods uint8                 // [bool]If set, invisible units are ignored for the OOBB used to select LOD steps.
	// contains filtered or unexported fields
}

type AnimationMergeOptions struct {
	MaxStartTime  float32 `json:"max_start_time"` // Sets the maximum time into an animation that we can start, in seconds. If a value of `0.2` is set, it means that if we can find any existing player playing this animation that has played for 0-0.2 seconds, then we will reuse that player instead of creating a new one. The animation will jump to the position where that player is, instead of starting at t=0. The default is `0`, which allows animation evaluations to be merged only if they began in the same frame.
	MaxDrift      float32 `json:"max_drift"`      // Controls how much the displayed animation time is allowed to drift from the actual animation time. If two animations that are sharing a player are played with different speeds, they will eventually drift apart. At some point the animations will be considered too different and the evaluator will be split in two. This parameter controls when that happens. A value of `0.2` means that if the animations differs more than 0.2 seconds, the evaluator will be split.
	ClockFidelity float32 `json:"clock_fidelity"` // This controls how much the animation will respect the set playing speed. By slightly changing the playing speed of an animation, the animation player can prevent two playing animations from drifting apart and thus forcing a split of the evaluators. A clock fidelity of `0.9` means that the speed will be within 90% of what has been requested: i.e. it is allowed to change by 10 percent. The default value of `1.0` means that the speed will be exactly what has been requested.
}

type AnimationVariable struct {
	Name  stingray.ThinHash // [string]The name of the animation variable to set.
	Value float32           // The value to set on the animation variable.
}

type ArcInfo struct {
	Type                              enum.ArcType             `json:"type"`
	Speed                             float32                  `json:"speed"`
	Distance                          float32                  `json:"distance"`
	DistanceAtMaxAngleSpread          float32                  `json:"distance_at_max_angle_spread"`
	DistanceAtMaxAngleSpreadFirstShot float32                  `json:"distance_at_max_angle_spread_first_shot"`
	MaxAngleSpread                    float32                  `json:"max_angle_spread"`
	MaxAngleSpreadFirstShot           float32                  `json:"max_angle_spread_first_shot"`
	MaxChainLength                    uint32                   `json:"max_chain_length"`
	MaxChainSplit                     uint32                   `json:"max_chain_split"`
	DamageInfoType                    enum.DamageInfoType      `json:"damage_info_type"`
	CameraShakePath                   string                   `json:"camera_shake_path"`    // [camera_shake]
	ParticleEffectPath                string                   `json:"particle_effect_path"` // [particles]
	ParticleLingerTime                float32                  `json:"particle_linger_time"`
	ExplosionEffectPath               string                   `json:"explosion_effect_path"` // [particles]
	HitEffectDamageType               enum.HitEffectDamageType `json:"hit_effect_damage_type"`
	HitAudioEvent                     uint32                   `json:"hit_audio_event"`
	BeamPath                          string                   `json:"beam_path"` // [unit]
	UnkInt1                           uint32                   `json:"unk_int1"`
	UnkBool                           bool                     `json:"unk_bool"`
	UnkInt2                           uint32                   `json:"unk_int2"`
}

type ArcWeaponComponent struct {
	Type                enum.ArcType // Type of arc it fires
	RoundsPerMinute     float32      // Rounds per minute depending on weapon setting.
	InfiniteAmmo        uint8        // [bool]True if this projectile weapon can never run out of ammo.
	RPCSyncedFireEvents uint8        // [bool]ONLY USE FOR SINGLE-FIRE/SLOW FIRING WEAPONS. Primarily useful for sniper rifles, explosive one-shots etc. that need the firing event to be highly accurately synced!

	FireSingleAudioEvent        stingray.ThinHash     // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	UnknownHash                 stingray.ThinHash     // Unknown, name length 27
	FireFailAudioEvent          stingray.ThinHash     // [wwise]The audio event to trigger when the arc fails to hit anything on the first shot.
	HapticsFireSingleAudioEvent stingray.ThinHash     // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	FireSourceNode              stingray.ThinHash     // [string]The node to play the firing audio events at.
	OnRoundFiredShakes          WeaponCameraShakeInfo // Settings for local and in-world camera shakes to play on every round fired.
	MuzzleFlash                 stingray.Hash         // [particles]Particle effect of the muzzle flash, played on attach_muzzle.
	MuzzleFlashFail             stingray.Hash         // [particles]Particle effect of the muzzle flash, when the arc weapon fails to hit, played on attach_muzzle.
	// contains filtered or unexported fields
}

type ArmorSet struct {
	Id           uint32
	DlcId        uint32
	SetId        uint32
	Name         string
	Description  string
	Rarity       CustomizationKitRarity
	Passive      *HelldiverCustomizationPassiveBonusSettings
	Type         CustomizationKitType
	Archive      stingray.Hash
	UnitMetadata map[stingray.Hash]UnitData
}

type AttachableComponent struct {
	DynamicActor         stingray.ThinHash // [string]Name of the dynamic actor that should be disabled when attached and enabled when dropped.
	AttachedDynamicActor stingray.ThinHash // [string]Name of the dynamic actor that should be enabled when attached and disabled when dropped.
	UseAllDynamicActors  uint8             // [bool]True if all dynamic actors should be disabled when attached and enabled when dropped.

	Offset                      mgl32.Vec3        // If set, this offset is applied on top of any other offsets when attaching the entity.
	RotationOffset              mgl32.Vec3        // If set, this rotation (in angles) is applied on top of any other offsets when attaching the entity.
	OffsetNode                  stingray.ThinHash // [string]If specified, the local space position and rotation of the node relative to the unit root will be added to the offset when attaching.
	AttachAnim                  stingray.ThinHash // [string]Animation to play when attaching.
	ParentAttachAnim            stingray.ThinHash // [string]Animation to play on the parent when attaching.
	DetachAnim                  stingray.ThinHash // [string]Animation to play when detaching.
	ParentDetachAnim            stingray.ThinHash // [string]Animation to play on the parent when detaching.
	AffectScale                 uint8             // [bool]This should only be applied to main entities that will attach to something in the world, like hellpods.
	IgnoreWeaponDamageForParent uint8             // [bool]This variable will decide if we should be able to damage our parent with our weapons.
	InheritAngularMomentum      uint8             // [bool]Should this attachable inherit angular momentum?
	UnknownBool1                uint8             // [bool]Unknown, name length 21
	UnknownBool2                uint8             // [bool]Unknown, name length 24
	UnknownBool3                uint8             // [bool]Unknown, name length 24
	// contains filtered or unexported fields
}

type AvatarComponent struct {
	InputInfo                    AvatarInputSettings           // Contains information about avatar input handling
	MovementInfo                 MoveInfo                      // Contains information about avatar movement
	SteepSlopeMovement           SteepSlopeMovementInfo        // Contains information about avatar movement in steep slopes
	SlideMovementInfo            ActionSlideMovementInfo       // Contains information about the avatar action slide
	ClimbInformation             ClimbInfo                     // Contains information about avatar climbing behaviour
	ShortThrowInfo               ThrowInfo                     // Contains information about throwing stuff underhand.
	LongThrowInfo                ThrowInfo                     // Contains information about throwing stuff overhand.
	DetectInfo                   DetectionInfo                 // Contains information about stealth and being detected.
	WeatheringSettings           AvatarWeatheringSettings      // Contains information about how fast dirt and wear and tear is added to the avatar.
	MovementHaptics              AvatarMovementHapticsSettings // Contains information about the avatar's movement haptics.
	ExertionLevels               [8]ExertionLevelInfo          // The different levels of exertion levels.
	ExertionVoiceOverParams      ExertionVoParams              // Different VO Events
	HealSelfDuration             float32                       // The duration in seconds it takes to heal yourself.
	HealSelfDecayWaitTime        float32                       // The duration in seconds to wait before starting to decaying healing progress.
	HealSelfDecayRate            float32                       // The rate at which your healing progress decays if not healing.
	HealSelfCancelDamageAmount   float32                       // The amount of damage you take for cancelling healing.
	RagdollDamageVelocityLower   float32                       // The lower value at which our limbs deal ragdoll damage.
	RagdollDamageVelocityUpper   float32                       // The upper value at which our limbs deal ragdoll damage.
	RagdollDamageMin             float32                       // The lowest amount of ragdoll damage we deal.
	RagdollDamageMax             float32                       // The highest amount of ragdoll damage we deal.
	RagdollDamageSnowModifier    float32                       // The modifier which we decrease ragdoll damage in snow by.
	MinAimDuration               float32                       // Time it takes to aim at max ergonomics level
	MaxAimDuration               float32                       // Time it takes to aim at min ergonomics level
	MinFireReadyDuration         float32                       // Time it takes to get ready to fire a shot at max ergonomics level
	MaxFireReadyDuration         float32                       // Time it takes to get ready to fire a shot at min ergonomics level
	TauntTimeBeforeDrain         float32                       // Time it takes for the taunt probability to start draining
	TauntDrainPerSecond          float32                       // How much of the taunt probability we drain per second
	TauntOnTriggerProbabilityMul float32                       // By how much do we multiply the probability upon a successful taunt?
	TauntCooldownTimer           float32
}

type AvatarInputSettings struct {
	HoldStanceButtonTimeForProne float32 `json:"hold_stance_button_time_for_prone"` // The time needed to hold down the Switch Stance button until prone is toggled
}

type AvatarMovementHapticsSettings struct {
	LeftSprinting  stingray.ThinHash // [wwise]Left sprinting haptic
	RightSprinting stingray.ThinHash // [wwise]Right sprinting haptic
	LeftJogging    stingray.ThinHash // [wwise]Left jogging haptic
	RightJogging   stingray.ThinHash // [wwise]Right jogging haptic
	LeftWalking    stingray.ThinHash // [wwise]Left walking haptic
	RightWalking   stingray.ThinHash // [wwise]Right walking haptic
	LeftCrouching  stingray.ThinHash // [wwise]Left crouching haptic
	RightCrouching stingray.ThinHash // [wwise]Right crouching haptic
	LeftCrawling   stingray.ThinHash // [wwise]Left crawling haptic
	RightCrawling  stingray.ThinHash // [wwise]Right crawling haptic
}

type AvatarWeatheringSettings struct {
	MoveSpeedRequirement float32 `json:"move_speed_requirement"` // Start adding dirt after moving at this speed.
	DirtSpeedStanding    float32 `json:"dirt_speed_standing"`    // How dirty to get while moving standing up.
	DirtSpeedCrouching   float32 `json:"dirt_speed_crouching"`   // How dirty to get while crouch moving.
	DirtSpeedProne       float32 `json:"dirt_speed_prone"`       // How dirty to get while crawling around.
	DirtSpeedSliding     float32 `json:"dirt_speed_sliding"`     // How dirty to get while sliding.
}

type BeamInfo struct {
	Type               enum.BeamType            `json:"type"`
	Radius             float32                  `json:"radius"`
	Length             float32                  `json:"length"`
	DamageInfoType     enum.DamageInfoType      `json:"damage_info_type"`
	FocalShoulderWidth float32                  `json:"focal_shoulder_width"`
	DecalSize          float32                  `json:"decal_size"`
	SurfaceImpactType  enum.SurfaceImpactType   `json:"surface_impact_type"`
	BeamEffectPath     string                   `json:"beam_effect_path"`    // [particles]
	FalloffEffectPath  string                   `json:"falloff_effect_path"` // [particles]
	BeamUnitPath       string                   `json:"beam_unit_path"`      // [unit]
	AudioTrail         uint32                   `json:"audio_trail"`
	AudioTrailStop     uint32                   `json:"audio_trail_stop"`
	RaycastTemplate    enum.RaycastTemplate     `json:"raycast_template"`
	OverlapBeamQuery   string                   `json:"overlap_beam_query"`
	EffectDamageType   enum.HitEffectDamageType `json:"effect_damage_type"`
	UnkFloat           float32                  `json:"unk_float"` // name length 18
	ExplosionType      enum.ExplosionType       `json:"explosion_type"`
	UnkBool            bool                     `json:"unk_bool"` // name length 27
	DangerLevel        enum.DangerLevel         `json:"danger_level"`
}

type BeamPrisms struct {
	LightBeamType          enum.BeamType `json:"light_beam_type"`
	LightHeatGenerationMul float32       `json:"light_heat_generation_mul"`
	HeavyBeamType          enum.BeamType `json:"heavy_beam_type"`
	HeavyHeatGenerationMul float32       `json:"heavy_heat_generation_mul"`
}

type BeamWeaponComponent struct {
	Type               enum.BeamType // Type of beam it fires.
	Prisms             BeamPrisms    // Beam Prism Settings for weapons with the weapon function.
	ScopeCrosshair     mgl32.Vec2    // Crosshair position on screen in [-1, 1] range.
	FocalDistances     mgl32.Vec3    // The focal distances of the weapon's lens
	UseFirenodePose    float32
	UseMidiEventSystem uint8 // [bool]Fire event will be posted using Wwise's MIDI system as a MIDI sequence (cannot be paused/resumed).

	MidiTimingRandomization mgl32.Vec2        // Events posted during the MIDI sequence will have a random time offset, measured in milliseconds.
	MidiStopDelay           float32           // A delay for when to notify Wwise that the MIDI sequence has stopped, measured in milliseconds.
	FireLoopStartAudioEvent stingray.ThinHash // [wwise] The looping audio event to start when starting to fire.
	FireLoopStopAudioEvent  stingray.ThinHash // [wwise] The looping audio event to play when stopping fire.
	FireSingleAudioEvent    stingray.ThinHash // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	UnkAudioEvent           stingray.ThinHash // name length 27

	MuzzleFlash                   stingray.Hash     // [particles]Muzzle flash effect
	NoiseTimer                    float32           // How often does the weapon make noise?
	FireSourceNode                stingray.ThinHash // [string]The node to play the firing audio events at.
	DryFireAudioEvent             stingray.ThinHash // [wwise]The wwise sound id to play when dry firing.
	DryFireRepeatAudioEvent       stingray.ThinHash // [wwise]The wwise sound id to play when repeatedly dry firing.
	OnFireStartedWielderAnimEvent stingray.ThinHash // [string]Animation event to trigger on the wielder when we start firing.
	OnFireStoppedWielderAnimEvent stingray.ThinHash // [string]Animation event to trigger on the wielder when we stop firing.
	UnkBool                       uint8             // name length 19

	UnkInt  int32 // name length 16
	UnkInt2 int32 // name length 19
	// contains filtered or unexported fields
}

type BehaviorComponent struct {
	BehaviorId   enum.BehaviorId `json:"behavior_id"`   // Id of behavior to use.
	TaskCooldown float32         `json:"task_cooldown"` // time before a task can be used again
	TaskUser     enum.TaskUser   `json:"task_user"`     // Which task user I am. Will decide which tasks I will be able to take.
}

type Body struct {
	Type          CustomizationKitBodyType
	Unk00         uint32
	PiecesAddress int64
	PiecesCount   int64
}

type CameraShake struct {
	Shake          stingray.Hash     // [camera_shake]
	NodeId         stingray.ThinHash // [string]
	Offset         mgl32.Vec3
	InnerRadius    float32
	InnerOuter     float32
	OrphanedPolicy enum.UnitEffectOrphanStrategy
	Linked         uint8
	// contains filtered or unexported fields
}

type CameraShakeSettings struct {
	ID stingray.ThinHash // [string]The id of this effect. Referenced when playing/stopping this particle effect.

	Settings  CameraShake                   // Camera shake settings.
	OnDestroy enum.UnitEffectOrphanStrategy // The strategy on how to handle the camera shake when this entity is destroyed.
	OnReplace enum.UnitEffectOrphanStrategy // The strategy on how to handle the camera shake when this entity is trying to play an effect that already exists.
	OnDeath   enum.UnitEffectOrphanStrategy // The strategy on how to handle the camera shake when this entity dies.
	// contains filtered or unexported fields
}

type CharacterNameComponent struct {
	Race               enum.RaceType     // Must not be none if the name should be selected from random templates.
	RandomNameTemplate stingray.ThinHash // [string]If not empty, use a random name from the name list and insert it into the NAME localization variable of the template.
	CharacterName      uint32            // [string]The localization string identifier of the character name, as displayed in subtitles.
	UsePersistentSeed  uint8             // [bool]If set, this character uses a predictable seed based on peer id. This is most useful for ship characters.
	// contains filtered or unexported fields
}

type ChargeStateSetting struct {
	ChargeTime         float32             `json:"charge_time"`
	ProjType           enum.ProjectileType `json:"projectile_type"`
	ProjectileParticle stingray.Hash       `json:"projectile_particle"`
	UnknownThinHash    stingray.ThinHash   `json:"unknown"` // 17 chars long name
	// contains filtered or unexported fields
}

type ClimbInfo struct {
	StartOffset                                mgl32.Vec3 `json:"start_offset"`                                      // Offset from root to climb point/ledge at the time we attach to it
	ClimbOffset                                mgl32.Vec3 `json:"climb_offset"`                                      // Offset from root to climb point/ledge at the time we reach hanging
	MinHeightFalling                           float32    `json:"min_height_falling"`                                // Min height falling
	MaxHeight                                  mgl32.Vec2 `json:"max_height"`                                        // Max height of an obstacle to be able to perform a climb (from gound and from air)
	MaxForwardDistance                         mgl32.Vec2 `json:"max_forward_distance"`                              // Max forward distance (from gound and from air)
	ForwardStartCheckDistancePerMeterPerSecond float32    `json:"forward_start_check_distance_per_meter_per_second"` // Distance forward per m/s movement speed to add to the minimum check distance
	MaxAutoStepUpHeight                        float32    `json:"max_auto_step_up_height"`                           // Indicates the maximun height with which we can trigger an auto step up climb.
	AutoStepUpCooldown                         float32    `json:"auto_step_up_cooldown"`                             // Indicates how much cooldown between auto step ups triggers we should have.
	ClimbRefInterpolationSpeed                 float32    `json:"climb_ref_interpolation_speed"`                     // climb reference interpolation speed
}

type Component interface {
	ToSimple(lookupHash HashLookup, lookupThinHash ThinHashLookup, lookupStrings StringsLookup) any
}

type ComponentDeltaSettings struct {
	ComponentIndex uint32                       `json:"component_index"`
	Deltas         []ComponentModificationDelta `json:"deltas,omitempty"`
}

type ComponentEntityDeltaStorage map[stingray.Hash]EntityDeltaSettings

type ComponentIndexData struct {
	Resource stingray.Hash
	Index    uint32
	// contains filtered or unexported fields
}

type ComponentModificationDelta struct {
	Offset uint32 `json:"offset"`
	Data   []byte `json:"data,omitempty"`
}

type CustomizationKitBodyType uint32

type CustomizationKitPieceType uint32

type CustomizationKitRarity uint32

type CustomizationKitSlot uint32

type CustomizationKitType uint32

type CustomizationKitWeight uint32

type DLArray struct {
	Offset int64
	Count  uint64
}

type DLBitfieldOrArrayLen uint16

type DLEnumDesc struct {
	Name       string            `json:"name"`
	NameOffset uint32            `json:"name_offset"`
	Flags      DLTypeFlags       `json:"flags"`
	Storage    DLTypeStorage     `json:"storage"`
	Values     []DLEnumValueDesc `json:"values"`
}

type DLEnumValueDesc struct {
	Name    string   `json:"name"`
	Comment string   `json:"comment,omitempty"`
	Value   uint64   `json:"value"`
	Aliases []string `json:"aliases,omitempty"`
}

type DLHash uint32

type DLHashLookup func(DLHash) string

type DLInstance struct {
	DLInstanceHeader
	Data []byte
}

type DLInstanceHeader struct {
	Magic   [4]byte
	Version uint32
	Type    DLHash
	Size    uint32
	Is64Bit uint8
	// contains filtered or unexported fields
}

type DLMemberDesc struct {
	Name         string      `json:"name"`
	NameOffset   uint32      `json:"name_offset"`
	Comment      string      `json:"comment,omitempty"`
	Type         DLType      `json:"type_flags"`
	TypeID       DLHash      `json:"type"`
	Size         uint32      `json:"size"`
	Alignment    uint32      `json:"alignment"`
	Offset       uint32      `json:"offset"`
	DefaultValue []uint8     `json:"-"`
	Flags        DLTypeFlags `json:"flags"`
}

type DLSubdata struct {
	DLSubdataHeader
	Data []byte
}

type DLSubdataHeader struct {
	Magic   [4]byte
	Version uint32
	Type    DLHash
	Size    uint32
	Is64Bit uint8
	// contains filtered or unexported fields
}

type DLType struct {
	Atom                   DLTypeAtom           `json:"atom"`
	Storage                DLTypeStorage        `json:"storage"`
	BitfieldInfoOrArrayLen DLBitfieldOrArrayLen `json:"union_arrayinfo_bfinfo"`
}

type DLTypeAtom uint8

type DLTypeDesc struct {
	Name          string         `json:"name"`
	NameOffset    uint32         `json:"name_offset"`
	Flags         DLTypeFlags    `json:"flags"`
	Size          uint32         `json:"size"`
	Alignment     uint32         `json:"alignment"`
	Members       []DLMemberDesc `json:"members,omitempty"`
	Comment       string         `json:"comment,omitempty"`
	CommentOffset uint32         `json:"comment_offset,omitzero"`
}

type DLTypeFlags uint32

type DLTypeLib struct {
	DLTypeLibHeader `json:"header"`
	Types           map[DLHash]DLTypeDesc `json:"types,omitempty"`
	Enums           map[DLHash]DLEnumDesc `json:"enums,omitempty"`
}

type DLTypeLibHeader struct {
	ID      [4]uint8 `json:"-"`
	Version uint32   `json:"version"`

	TypeCount      uint32 `json:"type_count"`
	EnumCount      uint32 `json:"enum_count"`
	MemberCount    uint32 `json:"member_count"`
	EnumValueCount uint32 `json:"enum_value_count"`
	EnumAliasCount uint32 `json:"enum_alias_count"`

	DefaultValueSize    uint32 `json:"default_value_size"`
	TypeInfoStringsSize uint32 `json:"typeinfo_strings_size"`
}

type DLTypeStorage uint8

type DLWidthDependentUInt32 [2]uint32

type DamageArmorAngles struct {
	Projectile [4]float32 `json:"projectile"`
	DPS        [4]float32 `json:"dps"`
}

type DamageInfo struct {
	Type                     enum.DamageInfoType      `json:"type"`
	Damage                   int32                    `json:"damage"`
	DurableDamage            int32                    `json:"durable_damage"`
	ArmorPenetrationPerAngle []uint32                 `json:"armor_penetration_per_angle"`
	DemolitionStrength       uint32                   `json:"demolition_strength"`
	ForceStrength            uint32                   `json:"force_strength"`
	ForceImpulse             uint32                   `json:"force_impulse"`
	ElementType              enum.ElementType         `json:"element_type"`
	StatusEffects            []DamageStatusEffectInfo `json:"status_effects,omitempty"`
}

type DamageSettings struct {
	Angles DamageArmorAngles `json:"angles"`
	Infos  []DamageInfo      `json:"infos"`
}

type DamageStatusEffectInfo struct {
	Type  enum.StatusEffectType `json:"type"`
	Value float32               `json:"value"`
}

type DamageableZone struct {
	Info   DamageableZoneInfo    // Damageable Zone Info
	Actors [24]stingray.ThinHash // [string]Damageable Zone Actors
}

type DamageableZoneInfo struct {
	OnDeadEffect         EffectSetting     // Particle effect to play when this damage zone dies
	OnDownedEffect       EffectSetting     // Particle effect to play when this damage zone gets downed.
	ZoneName             stingray.ThinHash // [string]The name of this zone
	OnDeadScriptEvent    stingray.ThinHash // [string]The script event to trigger when this damage zone dies.
	OnDeadAnimationEvent stingray.ThinHash // [string]The animation event to trigger when this damage zone dies.
	OnDeadUnknownEvent   stingray.ThinHash // Some event grouped with other on dead events with a name length of 31 chars.
	OnDeadAudioEvent     stingray.ThinHash // [wwise]The audio event to trigger when this damage zone dies.
	OnDeadAudioEventNode stingray.ThinHash // [string]The audio node to use when this damage zone dies.
	OnDeadUnknownBool    uint8             // An unknown bool with a name length of 34 chars

	OnDeadHideVisiblityGroup    stingray.ThinHash     // [string]Visibility group to hide when this damage zone dies.
	OnDeadShowVisiblityGroup    stingray.ThinHash     // [string]Visibility group to show when this damage zone dies.
	OnDeadHideVisiblityMask     stingray.ThinHash     // [string]Visibility mask to hide when this damage zone dies.
	OnDeadShowVisiblityMask     stingray.ThinHash     // [string]Visibility mask to show when this damage zone dies.
	OnDownedHideVisiblityMask   stingray.ThinHash     // [string]Visibility mask to hide when this damage zone gets downed.
	OnDownedShowVisiblityMask   stingray.ThinHash     // [string]Visibility mask to show when this damage zone gets downed.
	DestroyedAssignmentEvent    stingray.ThinHash     // [string]Assignment event tag to send when destroyed, either once when killed or once when entering downed state
	OnDeadLocomotionSet         stingray.ThinHash     // [string]The name of the locomotion set to activate when it dies. It will not trigger if another zone that affects locomotion is dead. In this case the locomotion set 'crawling' will be triggered.
	OnHitScriptEvent            stingray.ThinHash     // [string]The script event to trigger when this damage zone gets hit without taking damage.
	OnBleedoutScriptEvent       stingray.ThinHash     // [string]The script event to trigger when this damage zone gets bled out.
	OnDownedScriptEvent         stingray.ThinHash     // [string]The script event to trigger when this damage zone goes into constitution.
	OnHealScriptEvent           stingray.ThinHash     // [string]The script event to trigger when this damage zone gets healed.
	OnDownedAudioEvent          stingray.ThinHash     // [wwise]The audio event to trigger when this damage zone goes into constitution.
	OnDownedAudioEventNode      stingray.ThinHash     // [string]The audio node to use when this damage zone goes into constitution.
	OnDownedLocomotionSet       stingray.ThinHash     // [string]The name of the locomotion set to activate when it goes into constitution. It will not trigger if another zone that affects locomotion is dead. In this case the locomotion set 'crawling' will be triggered.
	OnDamageScriptEvent         stingray.ThinHash     // [string]The script event to trigger when this damage zone takes damage.
	UnknownThinHash             stingray.ThinHash     // name length 26
	DamageMultiplier            enum.DamageMultiplier // Damage Multiplier
	DamageMultiplierDPS         enum.DamageMultiplier // Damage Multipler for DPS weapons
	ProjectileDurableResistance float32               // Projectiles have 2 damages - Normal and Durable. This indicates how much it should scale the damage between the 2 values [Normal] -> [Durable].
	UnkFloat                    float32               // name length 33
	UnkFloat2                   float32               // name length 44
	Armor                       uint32                // Armor
	ArmorAngleCheck             uint8                 // [bool]Whether or not projectiles should check for armor penetration boost on hit.

	MaxArmor          uint32 // Maximum armor the angle check scales to.
	IgnoreArmorOnSelf uint8  // [bool]If checked, this entity does (not?) apply armor reduction on damage to itself, but still applies armor penetration reduction on the thing damaging it. Useful for shields that should take damage but stop projectiles/beams.

	Health               int32 // The max health of this zone
	Constitution         int32 // The max constitution of the zone
	Immortal             uint8 // [bool]If this is true, this zone cannot die until the entire entity dies.
	CausesDownedOnDowned uint8 // [bool]If this is true, the downing of this zone puts the entity in constitution.
	CausesDeathOnDowned  uint8 // [bool]If this is true, the downing of this zone triggers the immediate death of the entity.
	CausesDownedOnDeath  uint8 // [bool]If this is true, the death of this zone puts the entity in constitution.
	CausesDeathOnDeath   uint8 // [bool]If this is true, the death of this zone triggers the immediate death of the entity.

	AffectsMainHealth         float32               // As a multiplier between 0-1, this damage only affects the health pool of the damageable zone itself, not the entity's main health.
	ChildZones                [16]stingray.ThinHash // [string]The name of the zones that are children to this zone.
	KillChildrenOnDeath       uint8                 // [bool]If true, when this damageable zone dies we will kill all of it's child damageable zones as well.
	RegenerationEnabled       uint8                 // [bool]If true, this damage zone will regenerate when the health components regeneration cooldown isn't active.
	BleedoutEnabled           uint8                 // [bool]If true, this damage zone will start to bleedout when it's entered constitution.
	AffectedByExplosions      uint8                 // [bool]If true, explosions are applied to this damage zone. If not, the default zone is affected.
	ExplosiveDamagePercentage float32               // Looks like the amount of explosive damage taken - 27 chars long
	UnknownFloat2             float32               // idk, 28 chars long
	OnDeadDisableAllActors    uint8                 // [bool]If true, we disable all actors in this damage zone as it dies.
	UnknownBool               uint8                 // idk, 23 chars long

	ExplosionVerificationMode          enum.ExplosionVerificationMode // Defines when explosions are verified by raycast.
	MainHealthAffectCappedByZoneHealth uint8                          // [bool]If true, the main health contribution is capped by the health + constitutiuon of the damage zone. Should be true for zones that can be gibbed/dismembered.

	HitEffectReceiverType enum.HitEffectReceiverType // The type of hit effect to play when the zone gets hit. If this is set to HitEffectReceiverType_Count, it will assume the hit effect of the HitEffectComponent.
	UseSurfaceEffect      uint8                      // [bool]If enabled, will use the surface effect rather than the hit effect.

	HealthEventTriggers [4]HealthEventTrigger // Events that get played at certain health percentages.
	UnknownHash         stingray.ThinHash     // Unknown, 31 chars long
	UnknownFloat3       float32               // Unknown, 30 chars long
	UnknownBool2        uint8                 // Unknown, 9 chars long
	UnknownBool3        uint8                 // Unknown, 14 chars long
	// contains filtered or unexported fields
}

type DangerWarningComponent struct {
	WarningType   enum.DangerWarningType // Warning enum
	TriggerRadius float32                // If the player is within this radius that will show the warning. If less than 0 then always active
	StartActive   uint8                  // [bool]If true then this warning is active as soon as this entity exists
	// contains filtered or unexported fields
}

type DecaySettings struct {
	Mode         enum.DeathDecayMode `json:"mode"`         // If and how this entity decays on death.
	Acceleration float32             `json:"acceleration"` // Acceleration (m/s^2) of the decay velocity.
	MinDelay     float32             `json:"min_delay"`    // Only valid with Regular decay mode, this dictates how long to wait (at a minimum) before decaying,
	MaxDelay     float32             `json:"max_delay"`    // Only valid with Regular decay mode, this dictates how long to wait (at a maximum) before decaying,
	UnkFloat     float32             `json:"unk_float"`
	UnkBool      uint8               `json:"unk_bool"`
	// contains filtered or unexported fields
}

type DepositComponent struct {
	Capacity               uint32            // Total capacity.
	StartAmount            int32             // Initial capacity
	RefillAmount           uint32            // How much should this backpack be refilled for when getting ammo?
	DeductOwnerVoEvent     stingray.ThinHash // [string]VO event to play on the owner of the deposit component entity when being deducted.
	LastDeductOwnerVoEvent stingray.ThinHash // [string]VO event to play on the owner of the deposit component entity when deducting the last deduct.

	DronePath               stingray.Hash  // [adhd]If specified, the backpack will spawn the targeted drone.
	FriendlyInteractAbility enum.AbilityId // If specified, will enable other helldivers' interact zones, as long as you have ammo.
	SelfInteractAbility     enum.AbilityId // If specified, will allow you to self-interact with your backpack.
	ShowSelfInteract        uint8          // [bool]If we don't have an ability for this backpack, but still run self-interact logic, set this to true.

	NodeHidingOrder              [20]stingray.ThinHash // [string]Depending on the amount left, these nodes will be hidden accordingly.
	NodeHidingOrderPostAnimEvent stingray.ThinHash     // [string]After deducting, what animation should we play.
	RefillStyle                  enum.DepositRefill    // How does this deposit gain charges? Ammo/Meds/None etc.

	AssistedReloadWeaponPath stingray.Hash // [string]If specified, the backpack will only work with the specified assist-reloadable weapon.
	// contains filtered or unexported fields
}

type DetectionInfo struct {
	SightModifierStanding  float32 `json:"sight_modifier_standing"`  // Modifier for enemy sight range when standing up
	SightModifierCrouching float32 `json:"sight_modifier_crouching"` // Modifier for enemy sight range when crouching
	SightModifierProne     float32 `json:"sight_modifier_prone"`     // Modifier for enemy sight range when prone
}

type EffectReferenceComponent struct {
	CallOnDestroyOnEntityRemoval uint8 // [bool]Should this entity being removed count as the entity being destroyed

	Effects      [32]ParticleEffectSetting  // Particle Effect settings.
	Units        [8]SpawnUnitEffectSettings // The settings for units to spawn.
	CameraShakes [4]CameraShakeSettings     // The settings for camera shakes to spawn/not spawn..
	// contains filtered or unexported fields
}

type EffectSetting struct {
	ParticleEffect       stingray.Hash
	Offset               mgl32.Vec3
	RotationOffset       mgl32.Vec3
	NodeName             stingray.ThinHash
	TriggerEmitEventName stingray.ThinHash
	LinkOption           enum.UnitEffectOrphanStrategy
	Flags                EffectSettingFlags
}

type EffectSettingFlags uint32

type ElementDamage struct {
	Type  enum.ElementType `json:"type"`
	Value float32          `json:"value"`
}

type EncyclopediaEntryComponent struct {
	LocName               uint32 // [string]The localization string identifier of the name of this entity (type).
	LocNamePlural         uint32 // [string]Plural Variant of the name.
	LocNameUpper          uint32 // [string]Upper variant of the name.
	LocNameShort          uint32 // [string]Short variant of the name.
	LocNameShortUpper     uint32 // [string]Short and Upper variant of the name.
	Description           uint32 // [string]The localization string identifier the description of this entity.
	DescriptionUpper      uint32 // [string]Upper variant of the description
	DescriptionShort      uint32 // [string]Short variant of the description
	DescriptionShortUpper uint32 // [string]Short and Upper variant of the description
	Prefix                uint32 // [string]Prefix - used when doing fancy name displays.
	Fluff                 uint32 // [string]Similar to description, usually lore text.

	Icon stingray.Hash // [material]The icon to use for this entity (type).
	// contains filtered or unexported fields
}

type EnemyPackageComponent struct {
	BundleTag stingray.ThinHash // [string]The loadout package will be generated with this bundle tag. Has no runtime effect.

	Package          stingray.Hash // [package]The loadout package to laod for this entity.
	SubentityPackage stingray.Hash // Name length 17 chars.
	AudioResource    stingray.Hash // [wwise_dep]The wwise bank to include in the package for this entity.
	// contains filtered or unexported fields
}

type EnemyTagSwap struct {
	Tag  enum.EnemyTag
	Name stingray.ThinHash
}

type Entity struct {
	GameObjectID stingray.ThinHash
	Components   map[DLHash]Component
}

type EntityDeltaSettings struct {
	ModifiedComponents []ComponentDeltaSettings `json:"modified_components,omitempty"`
}

type EntityDeltaTypeData struct {
	ResourceID stingray.Hash
	Index      uint32
	// contains filtered or unexported fields
}

type EntitySettings struct {
	Resource         stingray.Hash
	ComponentsOffset uint64
	ComponentsCount  uint64
	GameObjectID     stingray.ThinHash
	// contains filtered or unexported fields
}

type EnvironmentSettings struct {
	PlanetType              enum.PlanetType               `json:"planet_type"`
	DebugName               string                        `json:"debug_name"`
	NameLoc                 string                        `json:"name_loc"`
	NameLocStr              string                        `json:"name_loc_str"`
	LoadoutIntelligenceLoc  string                        `json:"loadout_intelligence_loc"`
	WwiseStateStr           string                        `json:"wwise_state"`
	PlanetMaterialId        string                        `json:"planet_material_id"`
	EnvSharedPackage        string                        `json:"env_shared_package"`
	TerrainProjectorPackage string                        `json:"terrain_projector_package"`
	ShadingEnvironment      string                        `json:"shading_environment"`
	GradingDay              string                        `json:"grading_day"`
	GradingSunset           string                        `json:"grading_sunset"`
	GradingNight            string                        `json:"grading_night"`
	MinimapPackage          string                        `json:"minimap_package"`
	MinimapUtilityLevel     string                        `json:"minimap_utility_level"`
	DirtColor               mgl32.Vec3                    `json:"dirt_color"`
	LayerId                 string                        `json:"layer_id"`
	HologramLightColor      mgl32.Vec3                    `json:"hologram_light_color"`
	HologramOverlayColor    mgl32.Vec3                    `json:"hologram_overlay_color"`
	DropSelectRouteColor    mgl32.Vec3                    `json:"drop_select_route_color"`
	HologramMinimapLut      string                        `json:"hologram_minimap_lut"`
	PathSettings            []LevelGenerationPathSettings `json:"path_settings"`
	UtilityLevel            string                        `json:"utility_level"`
	ResourcePackages        []string                      `json:"resource_packages"`
	ResourceOverrideTags    uint32                        `json:"resource_override_tags"`
	TerrainMaterialPath     string                        `json:"terrain_material_path"`
	DefaultReverbZoneStr    string                        `json:"default_reverb_zone"`
	DefaultAmbienceSoundId  uint32                        `json:"default_ambience_sound_id"`
	WindWwiseStartEvent     uint32                        `json:"wind_wwise_start_event"`
	WindWwiseStopEvent      uint32                        `json:"wind_wwise_stop_event"`
	UnkEvent                uint32                        `json:"unk_event"`  // Name length 32
	UnkEvent2               uint32                        `json:"unk_event2"` // Name length 31
	UnkStr                  string                        `json:"unk_str"`    // Name length 23
	UnkFloat                float32                       `json:"unk_float"`  // Name length 29
}

type EquipmentComponent struct {
	WieldNode                 stingray.ThinHash // [string]Name of the node on the wielder that this equipment should be attached to when wielded.
	WieldNodeRotationOffset   mgl32.Vec3        // If set, this rotation offset is applied when wielded.
	WieldNodePositionOffset   mgl32.Vec3        // If set, this position offset is applied when wielded.
	HolsterNode               stingray.ThinHash // [string]Name of the node on the wielder that this equipment should be attached to when holstered.
	HolsterNodeRotationOffset mgl32.Vec3        // If set, this rotation offset is applied when holstered.
	HolsterNodePositionOffset mgl32.Vec3        // If set, this position offset is applied when holstered.
	HolsterDuration           float32           // The time it takes to holster this equipment.
	WieldDuration             float32           // The time it takes to wield this equipment.
	PickupDuration            float32           // The time it takes to pickup this equipment.
	UnknownHash               stingray.ThinHash // unknown, name length 23
	WieldAnimation            stingray.ThinHash // [string]Name of the animation to play on the wielder when wielding.
	PickupAnimation           stingray.ThinHash // [string]Name of the animation to play on the wielder when picking up otherwise fallback to wield animation.
	HolsterAnimation          stingray.ThinHash // [string]Name of the animation to play on the wielder when holstering.
	DropAnimation             stingray.ThinHash // [string]Name of the animation to play on the wielder when dropping.
	AmmocheckAnimation        stingray.ThinHash // [string]Name of the animation to play on the wielder when checking ammo.
	UnknownBool               uint8             // unknown, name length 30
	UnknownBool2              uint8             // unknown, name length 20

	HolsterDurationForAttach      float32                // The time it takes to have the equipment attach itself to the holster node when we start holstering.
	WieldDurationForAttach        float32                // The time it takes to have the equipment attach itself to the wield node when we start wielding.
	AttachLerpTime                float32                // Should we apply lerp to the attachable component when we wield/holster and if so, how long should it lerp for?
	OnHolsterAnimationEvent       stingray.ThinHash      // [string]Animation event to trigger when this entity is holstered.
	WieldAnimationSelf            stingray.ThinHash      // [string]Name of the animation to play on the equipment when wielding.
	PickupAnimationSelf           stingray.ThinHash      // [string]Name of the animation to play on the equipment when picking up otherwise fallback to wield animation.
	HolsterAnimationSelf          stingray.ThinHash      // [string]Name of the animation to play on the equipment when holstering.
	UnknownHash3                  stingray.ThinHash      // Unknown, name length 29
	EquipmentType                 enum.EquipmentType     // The category of this equipment piece, mostly used for AI purposes.
	DropMode                      enum.EquipmentDropMode // How the equipment should be treated when dropped.
	DropAudioEvent                stingray.ThinHash      // [wwise]Audio event to trigger when getting rid of an equipment.
	UnknownAudioEvent             stingray.ThinHash      // Unknown, name length 20, probably an audio event
	DropIconUi                    stingray.Hash          // Unknown, name length 12
	PickupAudioEvent              stingray.ThinHash      // [wwise]Audio event to trigger when putting on a new equipment.
	UnknownEvent2                 stingray.ThinHash      // Unknown, name length 21
	UnknownEvent3                 stingray.ThinHash      // Unknown, name length 33
	UnknownEvent4                 stingray.ThinHash      // Unknown, name length 32
	WeaponSwitchWieldAudioEvent   stingray.ThinHash      // [wwise]Audio event to trigger when wielding the weapon.
	WeaponSwitchHolsterAudioEvent stingray.ThinHash      // [wwise]Audio event to trigger when holstering the weapon.
	PickupAbility                 enum.AbilityId         // Ability to play when picking up from the ground. Currently only used for the avatar.
	DropAbility                   enum.AbilityId         // ability to play when dropping equipment
	GripType                      enum.WeaponGripType    // Grip type for this weapon.
	IsOneHanded                   uint8                  // [bool]Whether the weapon can be wielded in one hand or not.
	AllowWieldOnShip              uint8                  // [bool]If the weapon can be wielded while on the ship, only intended use for debug purposes.
	ShowInPickupWidget            uint8                  // [bool]True the equipment should be shown in the pickup widget.

	HolsterUnit             stingray.Hash            // [unit]Path to the holster unit. This is an additional unit to spawn on the holster node that doesn't move with the equipment. Useful for sheaths etc. Note that since it's an additional unit it's more expensive than building the sheath into the parent unit, so only use when needed.
	HintId                  stingray.ThinHash        // [string]Hint ID to trigger when equipping this equipment
	UnknownHash4            stingray.ThinHash        // Unknown, name length 14
	EquipmentWwiseIndex     enum.EquipmentWwiseIndex // the wwise item index for this equipment
	BackpackWwiseIndex      enum.BackpackWwiseIndex  // the wwise item index for this backpack if it is a backpack
	UseBackpackFilledSwitch uint8                    // [bool]If yes set_switch would be called on audio source before pickup drop foley and impact sounds

	UnknownHash5 stingray.ThinHash // Unknown, name length 22
	// contains filtered or unexported fields
}

type ErrorComponent struct {
	// contains filtered or unexported fields
}

type ExertionLevelInfo struct {
	Index                              enum.ExertionLevelIndex // The corresponding index to this level.
	ExertionThreshold                  float32                 // The Threshold of exertion that considers this level.
	SwayMultiplierScoped               float32                 // Multiplier to sway when scoped, changing its magnitude
	SwayMultiplierThirdperson          float32                 // Multiplier to sway in thirdperson, changing its magnitude
	SwayFrequencyMultiplierScoped      float32                 // Multiplier to sway when scoped, changing its frequency
	SwayFrequencyMultiplierThirdperson float32                 // Multiplier to sway in thirdperson, changing its frequency
	SwayRecoilMultiplierScoped         float32                 // Multiplier to sway when scoped, changing its recoil
	SwayRecoilMultiplierThirdperson    float32                 // Multiplier to sway in thirdperson, changing its recoil
	SwayInterpSpeed                    float32                 // The interpolation speed used for all sway values
	EnterAnimationEvent                stingray.ThinHash       // [string]The animation event to play when entering this exertion level.
	ExitAnimationEvent                 stingray.ThinHash       // [string]The animation event to play when exiting this exertion level.
	ExertionGrowsVo                    stingray.ThinHash       // [string]Breath Audio event
	ExertionRecoversVo                 stingray.ThinHash       // [string]Breath Audio event
}

type ExertionVoParams struct {
	OnDeath                  stingray.ThinHash // [string] audio event to play on death
	OnSpawn                  stingray.ThinHash // [string] audio event to play on spawn
	OnExertionStart          stingray.ThinHash // [string] audio event to play on exertion start
	OnExertionStop           stingray.ThinHash // [string] audio event to play on exertion stop
	OnBleedoutStop           stingray.ThinHash // [string] audio event to play on bleedout stop
	InjuryHpThreshold        float32           // injury_hp_threshold
	CriticalBleedHpThreshold float32           // critical_bleed_hp_threshold
}

type ExplorationRewardComponent struct {
	AbilityIdAtInteraction           enum.AbilityId    // Indicates the ability that the reward entity will play once the avatar interact with it.
	AudioEventAtInteraction          stingray.ThinHash // [wwise]Indicates the audio event that the reward entity will fire once the avatar interact with it.
	AnimationEventAtInteraction      stingray.ThinHash // [string]Indicates the animation event that the reward entity will fire once the avatar interact with it.
	AbilityIdAtInteractionInteractor enum.AbilityId    // Indicates the ability that the avatar will play once interacts with the reward.
	ShouldDestroyAfterInteraction    uint8             // [bool]Indicates if we should destroy the entity after interaction.

	DefaultExplorationRewardType enum.ExplorationRewardType // Indicates the reward type that we should give by default if we don't specify any script data in the marker.
	// contains filtered or unexported fields
}

type ExplosionInfo struct {
	Type                        enum.ExplosionType            `json:"type"`
	DamageType                  enum.DamageInfoType           `json:"damage_type"`
	UnkHash                     string                        `json:"unk_hash"`
	UnkBool                     uint8                         `json:"unk_bool"`
	InnerRadius                 float32                       `json:"inner_radius"`
	OuterRadius                 float32                       `json:"outer_radius"`
	StaggerRadius               float32                       `json:"stagger_radius"`
	ConeAngle                   float32                       `json:"cone_angle"`
	CameraShakeRadius           float32                       `json:"camera_shake_radius"`
	ShakeAssets                 []string                      `json:"shake_assets"`
	ParticleEffectPath          string                        `json:"particle_effect_path"`
	AudioEvent                  uint32                        `json:"audio_event"`
	CraterType                  enum.TerrainDeformationType   `json:"crater_type"`
	SurfaceImpactType           enum.SurfaceImpactType        `json:"surface_impact_type"`
	HitEffectDamageType         enum.HitEffectDamageType      `json:"hit_effect_damage_type"`
	NumShrapnelProjectiles      uint32                        `json:"num_shrapnel_projectiles"`
	ShrapnelProjectileType      enum.ProjectileType           `json:"shrapnel_projectile_type"`
	NoiseTemplate               enum.NoiseTemplate            `json:"noise_template"`
	WindEffectTemplate          enum.WindEffectTemplate       `json:"wind_effect_template"`
	FireTemplate                enum.FireTemplate             `json:"fire_template"`
	PersistentStatusVolume      enum.StatusEffectTemplateType `json:"persistent_status_volume"`
	StatusVolumeEffectTime      float32                       `json:"status_volume_effect_time"`
	StatusVolumeEffectAudioPlay uint32                        `json:"status_volume_effect_audio_play"`
	StatusVolumeEffectAudioStop uint32                        `json:"status_volume_effect_audio_stop"`
	ExplosionInfoBitfield1      `json:"explosion_info_bitfield1"`
	ArcType                     enum.ArcType `json:"arc_type"`
	ExplosionInfoBitfield2      `json:"explosion_info_bitfield2"`
	UnkFloat                    float32 `json:"unk_float"`
}

type ExplosionInfoBitfield1 uint8

type ExplosionInfoBitfield2 uint8

type ExplosionInfoBitfieldStruct1 struct {
	DoKnockback                 bool `json:"do_knockback"`
	DisableDefaultSurfaceImpact bool `json:"disable_default_surface_impact"`
	IsHugeExplosion             bool `json:"is_huge_explosion"`
	LookForAudioSourceHijack    bool `json:"look_for_audio_source_hijack"`
	Item4                       bool `json:"item4"`
}

type ExplosionInfoBitfieldStruct2 struct {
	Item0 bool `json:"item0"`
	Item1 bool `json:"item1"`
}

type ExplosiveComponent struct {
	Mode                    enum.ExplosiveMode   // Selects the mode of behavior for the explosive.
	CollisionRaycastFilter  enum.RaycastTemplate // Selects the filter used for raycast collision detection
	ArmingDelay             float32              // Time it takes to arm the explosive.
	ExplosionDelay          float32              // Time it takes from armed to explosion. For impact, this is the minimum timer!
	RemovalDelay            float32              // Time it takes to remove the explosive after detonating.
	StartActive             uint8                // [bool]The explosive has to be active before it can be armed.
	HideOnExplosion         uint8                // [bool]The explosive is hidden immediately on explosion, then removed later.
	DestroyActorOnExplosion uint8                // [bool]The explosive is hidden immediately on explosion, then removed later.
	IgnoreFriendlyFire      uint8                // [bool]The explosive will not trigger if colliding with friendlies.
	UnkBool                 uint8                // [bool] Name length 20

	ImpactDistance          float32            // The minimum distance ahead of the explosive's root to check for collisions that trigger the impact explosion.
	ImpactAirburstDistance  float32            // Impact Only! Distance to check to the ground to check for airburst explosion.
	ExplosionType           enum.ExplosionType // The type of explosion, see explosion_settings.h for types.
	ImpactExplosionType     enum.ExplosionType // The type of explosion, see explosion_settings.h for types.
	OnExplodedSound         uint32             // [wwise]The sound to play when this entity explodes. Outside of the actual explosion-sound.
	OnStatusEffectDoneSound uint32             // [wwise]The sound to play when the status effect is done.

	ArmedEffect                    EffectSetting                      // Particle effect to play (fire-and-forget) when this explosive is armed.
	TrailEffect                    EffectSetting                      // Particle effect to play when this entity is spawned and stop playing it when this entity stops moving.
	StatusEffectParticleEffect     EffectSetting                      // The particle effect to play when running the status effect
	StatusEffectDoneParticleEffect EffectSetting                      // The particle effect to play when the status effect is done (fire and forget).
	ArmedSound                     uint32                             // [wwise]The sound to play when this explosive is armed.
	StatusEffectTemplate           StatusEffectTimedSphericalTemplate // The status effects to apply if using TimedStatusEffect type.
	TriggerActor                   stingray.ThinHash                  // [string]The actor, if any, to enable when the explosive comes to rest in the world.
	CollisionActor                 stingray.ThinHash                  // [string]The actor, if any, to disable when the explosive comes to rest in the world.
	ExplodeOnDeath                 uint8                              // [bool]If the explosive dies via health component, should it explode?

	SomeVector     mgl32.Vec2     // Name length 37
	OnArmedAbility enum.AbilityId // If specified, this ability will be triggered when the explosive is armed.
	UnkFloat1      float32        // Name length 24
	UnkFloat2      float32        // Name length 29
	UnkBool2       uint8          // Name length 31
	UnkAbility     enum.AbilityId // Name length 30
	// contains filtered or unexported fields
}

type FactionComponent struct {
	Factions              [3]enum.FactionType   // Which factions this entity belongs to.
	TargetingNode         stingray.ThinHash     // [string]Node used for line of sight/aiming at entity.
	UnknownHashes         [4]stingray.Hash      // name length 28
	HalfWidth             float32               // Distance from which an enemy can attack you from the side.
	HalfForwardSize       float32               // Distance from which an enemy can attack you from the front or back.
	Priority              float32               // Used when selecting target
	UnknownFloat1         float32               // name length 22
	UnknownFloat2         float32               // name length 15
	ComplexTargetingNodes [16]stingray.ThinHash // [string]Multiple nodes specified for larger targets, such as vehicles
	UnknownBool           uint8                 // name length 17
	// contains filtered or unexported fields
}

type GetResourceFunc func(id stingray.FileID, typ stingray.DataType) (data []byte, exists bool, err error)

type HashLookup func(stingray.Hash) string

type HealthComponent struct {
	Health                   int32   // Max health
	HeathChangerate          float32 // How the health changes when not wounded, units per second
	HealthChangerateDisabled uint8   // [bool]If the regeneration is disabled

	HeathChangerateCooldown          float32 // How long after taking any damage to wait until we start regenerating.
	RegenerationSegments             uint32  // The number of segments for regeneration.
	RegenerationChangerate           float32 // How health changes in regeneration, units per seconds
	Constitution                     int32   // Negative health (after health is depleted the constitution ticks down until entity is dead)
	ConstitutionChangerate           float32 // The rate at which health is changed in constitution, units per second
	ConstitutionDisablesInteractions uint8   // [bool]Should interactions be disabled when this goes into constitution

	ZoneBleedoutChangerate float32       // The rate at which health is changed in constitution for zones, units per second
	Size                   enum.UnitSize // The size category of the unit, this is used for systems such as the gib system. Small = Humansized, Medium = Bug Warrior sized, Large = Tunneler, Massive = Even larger
	Mass                   float32       // The mass of the unit, this is used for systems such as vehicle collision damage calculations, when the unit is relying on a static or keyframed body.
	KillScore              uint32        // The score to accumulate when killing this.
	Wounded                WoundedState  // The effect wounds has on this character

	DefaultDamageableZoneInfo  DamageableZoneInfo // Contains information about default damage zone, which is used if no specific damage zone was hit
	DamageableZones            [38]DamageableZone // Contains all damage zones for the entity.
	ElementDamageValues        [4]ElementDamage
	Decay                      DecaySettings         // At least mode is required, for regular, more info may be needed
	DeathSoundIDs              [10]stingray.ThinHash // [wwise]Sounds to trigger when the entity experiences real death.
	TriggerDeathSoundsOnRemove uint8                 // [bool]Should this entity trigger death sounds if it gets removed?

	OnHitEffect       EffectSetting          // Particle effect to play when the entity gets hit by damage that is not dps.
	WhileLivingEffect [2]ActiveEffectSetting // Particle effects to play while the entity lives and is destroyed on death.
	OnDeathEffect     EffectSetting          // Particle effect to play when the entity dies.
	BledToDeathEffect EffectSetting          // Particle effect to play when the entity dies from bleeding out(cancels out the on_death_effect in that case).
	UnknownEffect     EffectSetting          // Unknown, 27 char long name
	RequireDemolition uint8                  // [bool]Does this entity require demolition damage to be damaged?

	DownedAnim                    stingray.ThinHash            // [string]Animation event that gets called when entering constitution.
	DeadAnim                      stingray.ThinHash            // [string]Animation event that gets called when entering death.
	UnknownFloat                  float32                      // Not sure, 31 char long name
	UnknownHash1                  stingray.ThinHash            // Unsure, 14 char name
	UnknownHash2                  stingray.ThinHash            // Unsure, 13 char name
	UnknownHash3                  stingray.ThinHash            // Unsure, 14 char name
	OnDownedHideVisibilityGroup   stingray.ThinHash            // [string]Visibility group to hide when this unit gets downed.
	OnDownedShowVisibilityGroup   stingray.ThinHash            // [string]Visibility group to show when this unit gets downed.
	OnDeadHideVisibilityGroup     stingray.ThinHash            // [string]Visibility group to hide when this unit dies.
	OnDeadShowVisibilityGroup     stingray.ThinHash            // [string]Visibility group to show when this unit dies.
	UnknownVisibilityGroupHashes  [4]stingray.ThinHash         // 29 char name, same as OnDead(Show/Hide)VisibilityGroup
	UnknownVisibilityGroupHashes2 [4]stingray.ThinHash         // 29 char name, same as OnDead(Show/Hide)VisibilityGroup
	UnknownDeathDestructionHash   stingray.ThinHash            // 26 char name, same as OnDeathDestructionLevel
	OnDeathDestructionLevel       enum.DestructionTemplateType // If this unit dies from the health component, then apply this level of destrction to itself from the destruction system
	CanDieNaturally               uint8                        // [bool]Normally if a unit takes enough damage, they'll die. If this is disabled, it will only go down to constitution and needs to be killed via outside forces, such as behavior.

	DeathPropagation enum.DeathPropagation // If this unit dies, It'll propagate the death to the selected inheritance direction selected in this field.
	UnknownHashArray [4]stingray.ThinHash  // Name length 17 chars
	UnknownBool1     uint8                 // Name length 33 chars
	UnknownBool2     uint8                 // Name length 18 chars
	UnknownBool3     uint8                 // Name length 30 chars
	// contains filtered or unexported fields
}

type HealthEventTrigger struct {
	HealthPercent     float32           // Health percent we need to go under in order to trip the event.
	EventName         stingray.ThinHash // [string]Event name that gets fired off to the behavior.
	UnknownEventName1 stingray.ThinHash // Could be animation, audio, bone, or other event name
	UnknownEventName2 stingray.ThinHash // Could be animation, audio, bone, or other event name
	UnknownEventName3 stingray.ThinHash // Could be animation, audio, bone, or other event name
}

type HeatsinkOverrides struct {
	HeatCapacity float32 // No clue really
	ProjType     enum.ProjectileType
	Particles    stingray.Hash
	MaybeEvent   stingray.ThinHash
	StatusEffect enum.StatusEffectType
}

type HelldiverCustomizationKit struct {
	Id               uint32
	DlcId            uint32
	SetId            uint32
	NameUpper        uint32
	NameCased        uint32
	Description      uint32
	Rarity           CustomizationKitRarity
	Passive          uint32
	Archive          stingray.Hash
	Type             CustomizationKitType
	Unk00            uint32
	BodyArrayAddress int64
	BodyCount        int64
}

type HelldiverCustomizationPassiveBonusModifier struct {
	ModifierId   string                                         `json:"modifier_id"`
	ModifierType HelldiverCustomizationPassiveBonusModifierType `json:"modifier_type"`
	Value        float32                                        `json:"value"`
	Description  string                                         `json:"description"`
}

type HelldiverCustomizationPassiveBonusModifierType uint32

type HelldiverCustomizationPassiveBonusSettings struct {
	PassiveBonus     uint32                                       `json:"id"`
	Name             string                                       `json:"name"`
	Icon             string                                       `json:"icon"`
	PassiveModifiers []HelldiverCustomizationPassiveBonusModifier `json:"passive_modifiers"`
	StatModifiers    []HelldiverCustomizationStatModifier         `json:"stat_modifiers,omitempty"`
	SomeString       string                                       `json:"some_string"`
}

type HelldiverCustomizationStatModifier struct {
	Stat      uint32  `json:"stat"`
	UnkFloat1 float32 `json:"unkfloat1"`
	UnkFloat2 float32 `json:"unkfloat2"`
}

type HellpodComponent struct {
	HellpodVariant enum.HellpodVariant // What kind of hellpod is this? Used for determining special-case settings.
	UnknownBool    uint8               // Unknown, 15 chars long

	SpawnHeight                float32    // At what Z level should the hellpod spawn?
	UnknownVec                 mgl32.Vec2 // unknown, 22 chars long
	InitialVelocity            float32    // What's the initial velocity of the hellpod?
	BreakingHeight             float32    // How far above ground should we start breaking? [sic]
	BreakingVelocity           float32    // What's the breaking velocity of the hellpod? [sic]
	BreakingVelocityTargetTime float32    // How long until we reach our breaking velocity? [sic]
	UnknownBool2               uint8      // unknown, 24 chars long

	AudioThrustersIgniteLoop        stingray.ThinHash // [string][wwise]Thruster Ignite Sound Loop
	AudioThrustersIgniteEnd         stingray.ThinHash // [string][wwise]Thruster Ignite Sound End
	AudioThrustersIgnition          stingray.ThinHash // [string][wwise]Thruster Ignite Sound
	AudioEntryWooshLoop             stingray.ThinHash // [string][wwise]Woosh Sound Loop
	AudioEntryWooshEnd              stingray.ThinHash // [string][wwise]Woosh Sound End
	AudioChassiShakeLoop            stingray.ThinHash // [string][wwise]Chassi Shake Sound Loop
	AudioChassiShakeEnd             stingray.ThinHash // [string][wwise]Chassi Shake Sound End
	AudioSupersonicBoom             stingray.ThinHash // [string][wwise]Supersonic Boom Sound
	AudioImpact                     stingray.ThinHash // [string][wwise]Impact Sound
	AudioBoltBlowing                stingray.ThinHash // [string][wwise]Bolt Blowing Sound
	AudioLidBlowing                 stingray.ThinHash // [string][wwise]Lid Blowing Sound
	AudioThrusterStart              stingray.ThinHash // [string][wwise]Thruster Start Sound
	AudioHellpodPreImpactRiser      stingray.ThinHash // [string][wwise]Hellpod Preimpact Riser Sound
	AudioMusicHellpodGroundApproach stingray.ThinHash // [string][wwise]Music Hellpod Ground Approach Switch
	AudioMusicHellpodLand           stingray.ThinHash // [string][wwise]Music Hellpod Land Switch
	UnknownBool3                    uint8             // Unknown, name length 12 chars
	// contains filtered or unexported fields
}

type HellpodPayloadComponent struct {
	RemoveTime       float32        `json:"remove_time"`        // The time between playing the retraction animation event and removing the entity.
	LifeTime         float32        `json:"life_time"`          // The life time of this payload. 0 is infinite.
	OnRetractAbility enum.AbilityId `json:"on_retract_ability"` // Ability to play on this unit when it's retracted.
}

type HellpodRackComponent struct {
	Payloads         [8]RackAttach // Payloads to attach (what & where).
	LastRetractDelay float32       // Extra time deloy to play the retract functionality on the last retracting attachment.
	DisableRetract   uint8         // [bool]Special case to disable the retract animations from playing on both sides of the rack.

	MapIcon                   stingray.Hash     // [material]Map Icon for this hellpod rack
	MapName                   uint32            // [string]Localization tag for the map name of this hellpod rack
	RackDeployAudioEvent      stingray.ThinHash // [wwise]
	RackRetractAudioEvent     stingray.ThinHash // [wwise]
	DoorRetractAudioEvent     stingray.ThinHash // [wwise]
	DeployAbility             enum.AbilityId    // Ability to play when deploying.
	LastRetractAbility        enum.AbilityId    // Ability to play when we are out of items.
	RandomPayloadSize         uint32            // If we have a random payload size above 0, then we will attach random items from the payload settings. Override spawn_payload_size
	SpawnPayloadSize          uint32            // Indicates how many payloads should spawn from the settings list.
	DisableInitialInteraction uint8             // [bool]Should we prevent the initial interaction for the payload, meaning you have to destroy the rack in order to get them?
	// contains filtered or unexported fields
}

type HitZoneClassValues struct {
	Normal  float32 `json:"normal"`
	Durable float32 `json:"durable"`
}

type HudMarkerTypeOverride struct {
	Node                stingray.ThinHash  // [string]What node to look for on the unit.
	MaxHitPosDistance   float32            // Max distance between raycast hit and node position.
	MaxHitAngDifference float32            // Max angle difference (2D) between raycast dir and node forward.
	MaxFuzzyDistance    float32            // Max fuzzy distance for the override, a combination between distance and FOV.
	MarkerType          enum.HudMarkerType // Maximum amount rewarded per pick-up. [sic]
}

type InteractZoneInfo struct {
	Name                stingray.ThinHash // [string]Name of the interactable zone.
	Radius              float32           // Radius of the interactable zone.
	ViewDistance        float32           // The distance at which the interactable icon is visible before it fades out.
	Node                stingray.ThinHash // [string]Name of the attach-node.
	Offset              mgl32.Vec3        // Offset from 'node'.
	StandLocationOffset mgl32.Vec3        // Location Offset from 'node', where the player will stand when interacting.
	InteractType        enum.InteractType // The type of interact.
	RequireMigration    uint8             // [bool]Need migration on interact.
	StartEnabled        uint8             // [bool]When spawn, should it be enabled or not?

	StartEnabledDelay         float32                     // When spawns, after how many second it should enable the interaction, -1 Indicates that the mechanism is disabled.
	Label                     uint32                      // [string]Localization string describing the interaction in the HUD.
	InactiveLabel             uint32                      // [string]Localization string describing an unavailable interaction in the HUD.
	ApproachDirection         float32                     // 2D angle between approaching unit and interactable, in the interactable's local space, that we center the interaction cone around
	ApproachAngle             float32                     // Half angle of the cone centered around approach_direction that we allow interaction in. If > 180 degreres, full circle is allowed.
	ApproachApexShift         float32                     // Shifts cone towards -direction
	ScreenBorder              int32                       // How far from the screen border interaction point should be. -1 can be interacted even offscreen
	ScriptEvent               stingray.ThinHash           // [string]Script event to be triggered on the interactable upon successful interact. - Require a Behavior Component on the the unit.
	ScriptEventForLinkedUnits stingray.ThinHash           // [string]Script event called on linked units to be triggered on the interactable upon successful interact.
	UnknownScriptEvent        stingray.ThinHash           // Name length 26
	Priority                  uint32                      // This interact zone's priority when within range of other zones. Higher priority values are favored over lower ones.
	BlockingInjuries          enum.InteractableInjuryType // Disable the interaction when the avatar have this injuries.
	ReenableImmediately       uint8                       // [bool]When used, re-enable the zone immediately
	DeleteAfterInteract       uint8                       // [bool]This will delete the entity after a successful interact.
	DisallowProneInteract     uint8                       // [bool]Disallows interacting when interactor is prone.
	UnknownBool               uint8                       // Name length 29
	UnknownBool2              uint8                       // Name length 25

	HoldTime             float32 // Hold time required to trigger this interact.
	HoverIconHeight      float32 // The in-world height offset of the interact type icon from the interact point.
	InteractDiamondScale float32 // The scale of the interact diamond.
	AutoInteract         uint8   // [bool]If enabled, users will trigger this zone by just getting in proximity
	ShowIfDisabled       uint8   // [bool]If true, then the disabled UI will be shown when this interact is disabled. If false then nothing will be shown.

	HintId    uint32 // [string] Hint to show
	OptHintId uint32 // [string] Second hint to show
	// contains filtered or unexported fields
}

type InteractableComponent struct {
	RequireWaitingForResult            uint8                 // [bool]Requires that the interactor needs to wait for the interaction before making new interacts.
	DisableInteractionWhileInteracting uint8                 // [bool]Indicates if we automatically disable the interactable zones when we are start the interaction
	AllowMove                          uint8                 // [bool]True if this interactable is allowed to move in the world.
	PerformLineOfSightCheck            uint8                 // [bool]True if this interactable should perform a line of sight check towards the interactor.
	Mode                               enum.InteractableMode // Describes who may interact with this interactable.
	Zones                              [8]InteractZoneInfo   // .
	InteractAudioEvent                 stingray.ThinHash     // [string]Audio event to trigger when the item is interacted with
	InteractAudioEventVo               stingray.ThinHash     // [string]Audio VO event to trigger when the item is interacted with
}

type InventoryComponent struct {
	DefaultPrimary     stingray.Hash // [adhd]Path to the primary equipment entity.
	DefaultSidearm     stingray.Hash // [adhd]Path to the sidearm equipment entity.
	DefaultSupport     stingray.Hash // [adhd]Path to the support equipment entity.
	DefaultThrowable   stingray.Hash // [adhd]Path to the throwable equipment entity.
	DefaultBackpack    stingray.Hash // [adhd]Path to the backpack entity.
	DefaultMeleeWeapon stingray.Hash // [adhd]Path to the melee entity.
	StartAmountStims   uint32        // max amount of stims. [sic]
	RefillAmountStims  uint32        // max amount of stims. [sic]
	MaxAmountStims     uint32        // max amount of stims.
	CanDropEquipment   uint8         // [bool]Indicates if this unit can drop the equipment or not

	UnknownHashArray [10]stingray.Hash // Unknown, name length 33
	// contains filtered or unexported fields
}

type LevelGenerationPathSettings struct {
	MeshMaterials         []string             `json:"mesh_materials"`
	MeshMaterialOpacities []float32            `json:"mesh_material_opacities"`
	SplineType            enum.StampSplineType `json:"spline_type"`
	CollisionWidth        float32              `json:"collision_width"`
	MeshWidth             float32              `json:"mesh_width"`
	MeshTilingLength      float32              `json:"mesh_tiling_length"`
	CreatesPathCollision  bool                 `json:"creates_path_collision"`
}

type LoadoutPackageComponent struct {
	BundleTag stingray.ThinHash // [string]The loadout package will be generated with this bundle tag. Has no runtime effect.

	Package                      stingray.Hash // [package]The loadout package to laod for this entity.
	AudioResource                stingray.Hash // [wwise_dep]The wwise bank to include in the package for this entity.
	IncludeDefaultCustomizations uint8         // [bool]If set any default customizations are included in the package generated for this .adhd file. Affects the entire package
	UnknownBool                  uint8         // [bool] unknown, 27 chars long
	// contains filtered or unexported fields
}

type LocalUnitComponent struct {
	UnitPath stingray.Hash // [unit]Path to the unit for this entity.
	Scale    float32       // Scale value.
}

type MagazinePattern struct {
	Projectiles     [32]enum.ProjectileType // Pattern of projectiles to fire. None denotes end if the full size is not used. Pattern is repeated and aligned so the last projectile in the pattern is always the last in the magazine (should it not divide evenly).
	FirstProjectile enum.ProjectileType     // to trigger start/stop event
}

type MaterialSwap struct {
	Name stingray.ThinHash // [string]The name of the swap.

	Material stingray.Hash // [material]The material to set.
	// contains filtered or unexported fields
}

type MaterialSwapComponent struct {
	MaterialSlots [8]MaterialSwapSlot  // Material slots that can be set
	EnemyNames    [8]stingray.ThinHash // name is guessed - name length 11
	EnemyTagSwaps [8]EnemyTagSwap
}

type MaterialSwapSlot struct {
	MaterialSlotName stingray.ThinHash // [string]The material slot to set on. If not set, then applied to all material slots.

	SwapSettings [8]MaterialSwap
	// contains filtered or unexported fields
}

type MaterialVariableAnimation struct {
	Name        stingray.ThinHash // [string]The name of the animation. Used to start and stop it from abilities.
	TargetValue mgl32.Vec4        // The target value to animate towards.
	Duration    float32           // The duration in seconds of the animation.
	Loops       uint32            // The amount of time this animation should loop, before ending. Setting it to 0 makes it infinite.
	AnimType    enum.MaterialVariableAnimationType
}

type MaterialVariableValue struct {
	Name  stingray.ThinHash
	Value mgl32.Vec4
}

type MaterialVariables struct {
	VariableName     stingray.ThinHash            // [string]The name of the material variable to set.
	MaterialSlotName stingray.ThinHash            // [string]The material slot to set on. If not set, then applied to all material slots.
	Type             enum.MaterialVariableType    // The type of the material variable to set.
	Value            mgl32.Vec4                   // The value to set on the material variable.
	Animations       [4]MaterialVariableAnimation // The animations that can be used on this variable.
	Values           [4]MaterialVariableValue     // The values that can be set on this variable
	UnknownBool1     uint8                        // unknown, name length 14
	UnknownBool2     uint8                        // unknown, name length 16
	// contains filtered or unexported fields
}

type MaterialVariablesComponent struct {
	Variables [8]MaterialVariables // Information about any variables that can be set / modified.
}

type MeleeAttackComponent struct {
	OverrideMeleeAbility         enum.AbilityId `json:"override_melee_ability"`           // If not invalid, it'll override the melee ability that gets executed while helding this entity, this could be a weapon, an attachment or a carryable.
	Weight                       uint32         `json:"weight"`                           // Used to indicate how much weight this override has when trying to pick the final override_melee_ability
	OverrideMeleeAbilityForProne enum.AbilityId `json:"override_melee_ability_for_prone"` // If not invalid, it'll override the melee ability that gets executed while being prone and helding this entity, this could be a weapon, an attachment or a carryable.
	WeightForProne               uint32         `json:"weight_for_prone"`                 // Used to indicate how much weight this override has when trying to pick the final override_melee_ability_for_prone
}

type MountComponent struct {
	Infos [5]MountInfo // Path and node info for each entity to mount.
}

type MountInfo struct {
	Path       stingray.Hash     // [adhd]Path to the adhd-entity to mount.
	AttachNode stingray.ThinHash // [string]Node where to attach the adhd-entity.
	MountSide  enum.MountSide    // Is this mounted on the left side of the parent, the right side of the parent, or neither side in particular?
	Name       stingray.ThinHash // [string]The name to use in scripts to refer to this mount.
	// contains filtered or unexported fields
}

type MoveInfo struct {
	Speeds                     MoveSpeeds `json:"speeds"`                        // Information about motion speed in the different states.
	SprintStaminaDecayDuration float32    `json:"sprint_stamina_decay_duration"` // The duration it takes for stamina to decay all the way to 0 when sprinting
	JogStaminaDecayDuration    float32    `json:"jog_stamina_decay_duration"`    // The duration it takes for stamina to decay all the way to 0 when jogging
	StaminaRecoverTimeStand    float32    `json:"stamina_recover_time_stand"`    // The duration until stamina is fully recovered while in stand
	StaminaRecoverTimeCrouch   float32    `json:"stamina_recover_time_crouch"`   // The duration until stamina is fully recovered while in crouch
	StaminaRecoverTimeProne    float32    `json:"stamina_recover_time_prone"`    // The duration until stamina is fully recovered while in prone
	StaminaRecoverDelay        float32    `json:"stamina_recover_delay"`         // The duration until stamina starts recovering
	StaminaCostJump            float32    `json:"stamina_cost_jump"`             // The stamina cost of jumping
	StaminaCostDodge           float32    `json:"stamina_cost_dodge"`            // The stamina cost of dodging
	StaminaCostVault           float32    `json:"stamina_cost_vault"`            // The stamina cost of vaulting
	StaminaCostClimb           float32    `json:"stamina_cost_climb"`            // The stamina cost of climbing
	StaminaCostSlide           float32    `json:"stamina_cost_slide"`            // The stamina cost of sliding
	VisibilityJump             float32    `json:"visibility_jump"`               // The stamina cost of jumping
	VisibilityDodge            float32    `json:"visibility_dodge"`              // The stamina cost of dodging
	VisibilityVault            float32    `json:"visibility_vault"`              // The stamina cost of vaulting
	VisibilityClimb            float32    `json:"visibility_climb"`              // The stamina cost of climbing
	VisibilitySlide            float32    `json:"visibility_slide"`              // The stamina cost of sliding
	HipfireTime                float32    `json:"hipfire_time"`                  // The time that the avatar remains in hipfire.
	ThrowHipfireTime           float32    `json:"throw_hipfire_time"`            // The time that the avatar remains in hipfire after throws.
	CrouchTurnSpeedMultiplier  float32    `json:"crouch_turn_speed_multiplier"`  // The turn speed multiplier used when crouching
	ProneTurnSpeedMultiplier   float32    `json:"prone_turn_speed_multiplier"`   // The turn speed multiplier used when prone
	JogTurnSpeedMultiplier     float32    `json:"jog_turn_speed_multiplier"`     // The turn speed multiplier used when jogging
	SprintTurnSpeedMultiplier  float32    `json:"sprint_turn_speed_multiplier"`  // The turn speed multiplier used when sprinting
	DownedTurnSpeedMultiplier  float32    `json:"downed_turn_speed_multiplier"`  // The turn speed multiplier used when downed
	SwimTurnSpeedMultiplier    float32    `json:"swim_turn_speed_multiplier"`    // The turn speed multiplier used when swimming
	SprintNoiseRadius          float32    `json:"sprint_noise_radius"`           // The noise radius when sprinting, enemies within range will be alerted
}

type MoveSpeeds struct {
	ReversingMultiplier float32 `json:"reversing_multiplier"` // A multiplier to movement speed when moving backwards.
	Aim                 float32 `json:"aim"`                  // Movement speed when aiming.
	Walk                float32 `json:"walk"`                 // Movement speed when walking.
	Jog                 float32 `json:"jog"`                  // Movement speed when jogging.
	Sprint              float32 `json:"sprint"`               // Movement speed when sprinting.
	SprintExerted       float32 `json:"sprint_exerted"`       // Movement speed when sprinting exerted.
	CrouchAim           float32 `json:"crouch_aim"`           // Movement speed when crouch aiming.
	CrouchWalk          float32 `json:"crouch_walk"`          // Movement speed when crouching.
	CrouchJog           float32 `json:"crouch_jog"`           // Movement speed when crouching.
	CrouchSprint        float32 `json:"crouch_sprint"`        // Movement speed when starting to crouch sprint.
	Prone               float32 `json:"prone"`                // Movement speed when in prone (or downed).
	Swim                float32 `json:"swim"`                 // Movement speed when swimming.
}

type OpticSetting struct {
	OpticsFunction enum.WeaponFunctionType
	SomeHash       stingray.ThinHash
	CrosshairValue enum.CrosshairWeaponType
}

type ParticleEffectSetting struct {
	Effect         EffectSetting     // Particle effect.
	ID             stingray.ThinHash // [string]The id of this effect. Referenced when playing/stopping this particle effect.
	TriggerOnSpawn uint8             // [bool]Should this effect be triggered on spawn?
	UnkBool        uint8             // [bool] Name length 19

	OnDestroy enum.UnitEffectOrphanStrategy // The strategy on how to handle the particle effect when this entity is destroyed.
	OnReplace enum.UnitEffectOrphanStrategy // The strategy on how to handle the particle effect when this entity is trying to play an effect that already exists.
	OnDeath   enum.UnitEffectOrphanStrategy // The strategy on how to handle the particle effect when this entity dies.
	OnStop    enum.UnitEffectOrphanStrategy // The strategy on how to handle the particle effect we stop the particle effect via effect reference.
	UnkBool2  uint8                         // [bool] Name Length 15
	// contains filtered or unexported fields
}

type Piece struct {
	Path              stingray.Hash
	Slot              CustomizationKitSlot
	Type              CustomizationKitPieceType
	Weight            CustomizationKitWeight
	Unk00             uint32
	MaterialLut       stingray.Hash
	PatternLut        stingray.Hash
	CapeLut           stingray.Hash
	CapeGradient      stingray.Hash
	CapeNac           stingray.Hash
	DecalScalarFields stingray.Hash
	BaseData          stingray.Hash
	DecalSheet        stingray.Hash
	ToneVariations    stingray.Hash
}

type ProjectileInfo struct {
	Type                              enum.ProjectileType                       `json:"type"`
	NameUpper                         string                                    `json:"name_upper"`
	NameCased                         string                                    `json:"name_cased"`
	ShortName                         string                                    `json:"short_name"`
	HudIcon                           string                                    `json:"hud_icon"` // [material]
	Calibre                           float32                                   `json:"calibre"`
	NumProjectiles                    uint32                                    `json:"num_projectiles"`
	Speed                             float32                                   `json:"speed"`
	Mass                              float32                                   `json:"mass"`
	Drag                              float32                                   `json:"drag"`
	GravityMultiplier                 float32                                   `json:"gravity_multiplier"`
	SimulationSteps                   uint32                                    `json:"simulation_steps"`
	UnkFloat                          float32                                   `json:"unk_float"` // Name length 16, maybe simulation_delta?
	LifeTime                          float32                                   `json:"life_time"`
	DamageInfoType                    enum.DamageInfoType                       `json:"damage_info_type"`
	PenetrationSlowdown               float32                                   `json:"penetration_slowdown"`
	ParticleThrusterEffectPath        string                                    `json:"particle_thruster_effect_path"`          // [particles]
	LowAmmoParticleThrusterEffectPath string                                    `json:"low_ammo_particle_thruster_effect_path"` // [particles]
	ParticleThrusterEffectLength      float32                                   `json:"particle_thruster_effect_length"`
	ParticleTrailEffectPath           string                                    `json:"particle_trail_effect_path"`          // [particles]
	DissipateParticleEffectPath       string                                    `json:"dissipate_particle_effect_path"`      // [particles]
	DisintegrationParticleEffectPath  string                                    `json:"disintegration_particle_effect_path"` // [particles]
	HitDirectionHintEffect            string                                    `json:"hit_direction_hint_effect"`           // [particles]
	ProjectileUnitPath                string                                    `json:"projectile_unit_path"`                // [unit]
	ExplosionThresholdAngle           float32                                   `json:"explosion_threshold_angle"`
	UnkBool                           bool                                      `json:"unk_bool"` // Name length 23
	ExplosionTypeOnImpact             enum.ExplosionType                        `json:"explosion_type_on_impact"`
	ExplosionProximity                float32                                   `json:"explosion_proximity"`
	ExplosionDelay                    float32                                   `json:"explosion_delay"`
	ExplosionTypeExpire               enum.ExplosionType                        `json:"explosion_type_expire"`
	ArmingDistance                    float32                                   `json:"arming_distance"`
	DecalSize                         float32                                   `json:"decal_size"`
	SurfaceImpactType                 enum.SurfaceImpactType                    `json:"surface_impact_type"`
	RicochetImpactType                enum.SurfaceImpactType                    `json:"ricochet_impact_type"`
	MaxRicochets                      uint32                                    `json:"max_ricochets"`
	RicochetThresholdAngle            float32                                   `json:"ricochet_threshold_angle"`
	RicochetThresholdSpeed            float32                                   `json:"ricochet_threshold_speed"`
	RicochetAngleLoss                 float32                                   `json:"ricochet_angle_loss"`
	RicochetSpreadVertical            float32                                   `json:"ricochet_spread_vertical"`
	RicochetSpreadHorizontal          float32                                   `json:"ricochet_spread_horizontal"`
	AudioCrackEvent                   uint32                                    `json:"audio_crack_event"`
	AudioRicochetEvent                uint32                                    `json:"audio_ricochet_event"`
	AudioTrailEventStart              uint32                                    `json:"audio_trail_event_start"`
	AudioTrailEventStop               uint32                                    `json:"audio_trail_event_stop"`
	UnkFloat2                         float32                                   `json:"unk_float2"`      // name length 31
	UnkAudioEvent                     string                                    `json:"unk_audio_event"` // name length 28
	UnkBool2                          uint8                                     `json:"unk_bool2"`       // name length 28
	StatusEffectVolumeTemplate        enum.ProjectileStatusEffectVolumeTemplate `json:"status_effect_volume_template"`
	EffectDamageType                  enum.HitEffectDamageType                  `json:"effect_damage_type"`
	FireTemplate                      enum.FireTemplate                         `json:"fire_template"`
	UnkBitfield                       ProjectileInfoBitfield1                   `json:"unk_bitfield"`
	RaycastTemplate                   enum.RaycastTemplate                      `json:"raycast_template"`
	UnkAudioEvent2                    string                                    `json:"unk_audio_event2"` // Could also be a thinhash? Name length 36
	UnkBitfield2                      ProjectileInfoBitfield2                   `json:"unk_bitfield2"`
	UnkVector                         mgl32.Vec3                                `json:"unk_vector"` // name length 34
}

type ProjectileInfoBitfield1 uint16

type ProjectileInfoBitfield2 uint8

type ProjectileInfoBitfieldStruct1 struct {
	Item0  bool `json:"item0"`
	Item1  bool `json:"item1"`
	Item2  bool `json:"item2"`
	Item3  bool `json:"item3"`
	Item4  bool `json:"item4"`
	Item5  bool `json:"item5"`
	Item6  bool `json:"item6"`
	Item7  bool `json:"item7"`
	Item8  bool `json:"item8"`
	Item9  bool `json:"item9"`
	Item10 bool `json:"item10"`
	Item11 bool `json:"item11"`
	Item12 bool `json:"item12"`
}

type ProjectileInfoBitfieldStruct2 struct {
	Item0 bool `json:"item0"`
	Item1 bool `json:"item1"`
}

type ProjectileMultipliers struct {
	SpeedMultiplierMin              float32 `json:"speed_multiplier_min"`              // The value to multiply the projectile speed with when at the smallest charge amount.
	SpeedMultiplierOvercharge       float32 `json:"speed_multiplier_overcharge"`       // The value to multiply the projectile speed with when fully overcharged.
	DamageMultiplierMin             float32 `json:"damage_multiplier_min"`             // The value to multiply the projectile damage with when at the smallest charge amount.
	DamageMultiplierOvercharge      float32 `json:"damage_multiplier_overcharge"`      // The value to multiply the projectile damage with when fully overcharged.
	PenetrationMultiplierMin        float32 `json:"penetration_multiplier_min"`        // The value to multiply the projectile penetration with when at the smallest charge amount.
	PenetrationMultiplierOvercharge float32 `json:"penetration_multiplier_overcharge"` // The value to multiply the projectile penetration with when fully overcharged.
	DistanceMultiplerMin            float32 `json:"distance_multipler_min"`            // The value to multiply the arc distance with when at the smallest charge amount.
	DistanceMultiplerOvercharge     float32 `json:"distance_multipler_overcharge"`     // The value to multiply the arc distance with when fully overcharged.
	ExtraArcSplitsMin               float32 `json:"extra_arc_splits_min"`              // The amount of extra splits this arc can do with minimum charge amount.
	ExtraArcSplitsOvercharge        float32 `json:"extra_arc_splits_overcharge"`       // The amount of extra splits this arc can do when fully overcharged.
	ExtraArcChainsMin               float32 `json:"extra_arc_chains_min"`              // The amount of extra chains this arc can do with minimum charge amount.
	ExtraArcChainsOvercharge        float32 `json:"extra_arc_chains_overcharge"`       // The amount of extra chains this arc can do when fully overcharged.
}

type ProjectileWeaponComponent struct {
	ProjType           enum.ProjectileType // Type of projectile it fires.
	RoundsPerMinute    mgl32.Vec3          // Rounds per minute depending on weapon setting. Y is the default ROF.
	ZeroingSlots       mgl32.Vec3          // The zeroing distances of the weapon.
	ZeroingHipfire     float32             // The default zeroing distance while not aiming a weapon
	CurrentZeroingSlot uint32              // The slot in the zeroing distances to use by default.
	InfiniteAmmo       uint8               // [bool]True if this projectile weapon can never run out of ammo.

	ProjectileEntity      stingray.Hash     // [adhd]If this is set an entity is spawned when firing instead of adding a projectile to the projectile manager.
	UseFirenodePose       float32           // This may not be correct, the type has changed since the last time this member had a name
	HeatBuildup           WeaponHeatBuildup // Controls visual heat effects on the weapon.
	ScaleDownUsedFireNode uint8             // [bool]If set, scale down the used fire node to zero (in order to hide a rocket for example)

	OnRoundFiredShakes     WeaponCameraShakeInfo   // Settings for local and in-world camera shakes to play on every round fired.
	NumLowAmmoRounds       uint32                  // Number of rounds to play the low ammo effects
	LowAmmoAudioEvent      stingray.ThinHash       // [string]Audio event to play in addition to the regular firing audio when low on ammo.
	LastBulletAudioEvent   stingray.ThinHash       // [string]Audio event to play in addition to the regular firing audio for the last bullet.
	LastBulletOwnerVOEvent stingray.ThinHash       // [string]VO event to play on the owner of the weapon when the last bullet has been fired.
	WindEffect             enum.WindEffectTemplate // Wind effect template to play when firing.
	SpeedMultiplier        float32                 // Projectile speed multiplier.
	DamageAddends          HitZoneClassValues      // Damage to add to the projectile's value for each damage class. Used by weapon customizaitons.
	APAddends              HitZoneClassValues      // Armor penetration to add to the projectile's value for each damage class. Used by weapon customizaitons.
	SpinupTime             float32                 // Time from 'start fire' to first projectile firing
	RPCSyncedFireEvents    uint8                   // [bool]ONLY USE FOR SINGLE-FIRE/SLOW FIRING WEAPONS. Primarily useful for sniper rifles, explosive one-shots etc. that need the firing event to be highly accurately synced!

	CasingEject        WeaponCasingEffectInfo // Particle effect of the shellcasing.
	MuzzleFlash        stingray.Hash          // [particles]Particle effect of the muzzle flash, played on attach_muzzle.
	ShockwaveType      enum.SurfaceImpactType // The surface effect to play normal to the ground underneath the muzzle.
	UseFaintShockwave  uint8                  // [bool]If true, a small shockwave is played when [1m, 2m] from the ground instead of the regular one.
	UseMidiEventSystem uint8                  // [bool]Fire event will be posted using Wwise's MIDI system as a MIDI sequence (cannot be paused/resumed).

	MidiTimingRandomization        mgl32.Vec2        // Events posted during the MIDI sequence will have a random time offset, measured in milliseconds.
	MidiStopDelay                  float32           // A delay for when to notify Wwise that the MIDI sequence has stopped, measured in milliseconds.
	FireLoopStartAudioEvent        stingray.ThinHash // [wwise]The looping audio event to start when starting to fire.
	FireLoopStopAudioEvent         stingray.ThinHash // [wwise]The looping audio event to play when stopping fire.
	FireSingleAudioEvent           stingray.ThinHash // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).
	FireReflectAudioEvent          stingray.ThinHash // [wwise]The audio event to trigger to simulate an early reflection.
	SilencedFireReflectAudioEvent  stingray.ThinHash // [wwise]The audio event to trigger to simulate an early reflection, with silencer equipped.
	HapticsFireLoopStartAudioEvent stingray.ThinHash // [wwise]The looping audio event to start when starting to fire.
	HapticsFireLoopStopAudioEvent  stingray.ThinHash // [wwise]The looping audio event to play when stopping fire.
	HapticsFireSingleAudioEvent    stingray.ThinHash // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds).

	FireLoopCameraShake             stingray.Hash     // [camera_shake]The camera shake to run when firing
	FireLoopCameraShakeRadius       mgl32.Vec2        // Inner/outer camera shake radiuses when firing.
	SilencedFireLoopStartAudioEvent stingray.ThinHash // [wwise]The looping audio event to start when starting to fire with suppressor.
	SilencedFireLoopStopAudioEvent  stingray.ThinHash // [wwise]The looping audio event to play when stopping fire with suppressor.
	SilencedFireSingleAudioEvent    stingray.ThinHash // [wwise]The audio event to trigger when doing single-fire (if we don't have looping sounds) with suppressor.
	FireSourceNode                  stingray.ThinHash // [string]The node to play the firing audio events at.
	DryFireAudioEvent               stingray.ThinHash // [wwise]The wwise sound id to play when dry firing.
	DryFireRepeatAudioEvent         stingray.ThinHash // [wwise]The wwise sound id to play when repeatedly dry firing.
	HeatPercentageMaterialVariable  stingray.ThinHash // [string]The material variable to try to set on each mesh when heat is updated
	Silenced                        uint8             // [bool]If this weapon should use the silenced sound or not. Used by / overridden by customization

	AimZeroingQuality         enum.ProjectileZeroingQuality // How well to attempt to compensate for drag when aiming. Defaults to High (8 iterations). Set to None to ignore drag.
	CasingEjectDisabledOnFire uint8                         // [bool]Turns off casing ejection/effects when firing the weapon.

	BurstFireRate                float32             // If above 0, the fire rate will be changed to this, when the weapon is set to Burst.
	WeaponFunctionMuzzleVelocity float32             // If we have the Muzzle Velocity weapon function and we switch to it, what should our projectile velocity be?
	WeaponFunctionProjectileType enum.ProjectileType // If we have the Programmable Ammo weapon function and we switch to it, what should our projectile type be?
	UnknownParticleHash          stingray.Hash       // added after strings removed
	UnknownBool                  uint8               // added after strings removed

	UnknownEnum  uint32    // name length 35
	UnknownArray [3]uint32 // name length 19
	// contains filtered or unexported fields
}