importonly class TweakDBRecord extends IScriptable
{
	public import function GetID() : TweakDBID;
	public import function GetRecordID() : TweakDBID;
}

importonly class AIAbilityCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Abilities( out outList : array< weak< GameplayAbility_Record > > );
	public import function GetAbilitiesCount() : Int32;
	public import function GetAbilitiesItem( index : Int32 ) : weak< GameplayAbility_Record >;
	public import function GetAbilitiesItemHandle( index : Int32 ) : GameplayAbility_Record;
	public import function AbilitiesContains( item : weak< GameplayAbility_Record > ) : Bool;
}

importonly class AIAction_Record extends AINode_Record
{
	public import function AnimData() : weak< AIActionAnimData_Record >;
	public import function AnimDataHandle() : AIActionAnimData_Record;
	public import function Recovery() : weak< AIActionPhase_Record >;
	public import function RecoveryHandle() : AIActionPhase_Record;
	public import function Startup() : weak< AIActionPhase_Record >;
	public import function StartupHandle() : AIActionPhase_Record;
	public import function RecoveryEndCondition() : weak< AIActionOR_Record >;
	public import function RecoveryEndConditionHandle() : AIActionOR_Record;
	public import function StartupRepeatCondition() : weak< AIActionOR_Record >;
	public import function StartupRepeatConditionHandle() : AIActionOR_Record;
	public import function StartupEndCondition() : weak< AIActionOR_Record >;
	public import function StartupEndConditionHandle() : AIActionOR_Record;
	public import function LoopRepeatCondition() : weak< AIActionOR_Record >;
	public import function LoopRepeatConditionHandle() : AIActionOR_Record;
	public import function RecoveryRepeatCondition() : weak< AIActionOR_Record >;
	public import function RecoveryRepeatConditionHandle() : AIActionOR_Record;
	public import function Ability() : weak< GameplayAbility_Record >;
	public import function AbilityHandle() : GameplayAbility_Record;
	public import function LoopEndCondition() : weak< AIActionOR_Record >;
	public import function LoopEndConditionHandle() : AIActionOR_Record;
	public import function Loop() : weak< AIActionPhase_Record >;
	public import function LoopHandle() : AIActionPhase_Record;
	public import function LoopSubActions( out outList : array< weak< AISubAction_Record > > );
	public import function GetLoopSubActionsCount() : Int32;
	public import function GetLoopSubActionsItem( index : Int32 ) : weak< AISubAction_Record >;
	public import function GetLoopSubActionsItemHandle( index : Int32 ) : AISubAction_Record;
	public import function LoopSubActionsContains( item : weak< AISubAction_Record > ) : Bool;
	public import function StartupSubActions( out outList : array< weak< AISubAction_Record > > );
	public import function GetStartupSubActionsCount() : Int32;
	public import function GetStartupSubActionsItem( index : Int32 ) : weak< AISubAction_Record >;
	public import function GetStartupSubActionsItemHandle( index : Int32 ) : AISubAction_Record;
	public import function StartupSubActionsContains( item : weak< AISubAction_Record > ) : Bool;
	public import function RecoverySubActions( out outList : array< weak< AISubAction_Record > > );
	public import function GetRecoverySubActionsCount() : Int32;
	public import function GetRecoverySubActionsItem( index : Int32 ) : weak< AISubAction_Record >;
	public import function GetRecoverySubActionsItemHandle( index : Int32 ) : AISubAction_Record;
	public import function RecoverySubActionsContains( item : weak< AISubAction_Record > ) : Bool;
	public import function SubActions( out outList : array< weak< AISubAction_Record > > );
	public import function GetSubActionsCount() : Int32;
	public import function GetSubActionsItem( index : Int32 ) : weak< AISubAction_Record >;
	public import function GetSubActionsItemHandle( index : Int32 ) : AISubAction_Record;
	public import function SubActionsContains( item : weak< AISubAction_Record > ) : Bool;
	public import function Cooldowns( out outList : array< weak< AIActionCooldown_Record > > );
	public import function GetCooldownsCount() : Int32;
	public import function GetCooldownsItem( index : Int32 ) : weak< AIActionCooldown_Record >;
	public import function GetCooldownsItemHandle( index : Int32 ) : AIActionCooldown_Record;
	public import function CooldownsContains( item : weak< AIActionCooldown_Record > ) : Bool;
	public import function Tickets( out outList : array< weak< AITicketType_Record > > );
	public import function GetTicketsCount() : Int32;
	public import function GetTicketsItem( index : Int32 ) : weak< AITicketType_Record >;
	public import function GetTicketsItemHandle( index : Int32 ) : AITicketType_Record;
	public import function TicketsContains( item : weak< AITicketType_Record > ) : Bool;
	public import function InitCooldowns( out outList : array< weak< AIActionCooldown_Record > > );
	public import function GetInitCooldownsCount() : Int32;
	public import function GetInitCooldownsItem( index : Int32 ) : weak< AIActionCooldown_Record >;
	public import function GetInitCooldownsItemHandle( index : Int32 ) : AIActionCooldown_Record;
	public import function InitCooldownsContains( item : weak< AIActionCooldown_Record > ) : Bool;
	public import function Commands() : array< CName >;
	public import function GetCommandsCount() : Int32;
	public import function GetCommandsItem( index : Int32 ) : CName;
	public import function CommandsContains( item : CName ) : Bool;
	public import function Lookats( out outList : array< weak< AIActionLookAtData_Record > > );
	public import function GetLookatsCount() : Int32;
	public import function GetLookatsItem( index : Int32 ) : weak< AIActionLookAtData_Record >;
	public import function GetLookatsItemHandle( index : Int32 ) : AIActionLookAtData_Record;
	public import function LookatsContains( item : weak< AIActionLookAtData_Record > ) : Bool;
	public import function AnimationWrapperOverrides() : array< CName >;
	public import function GetAnimationWrapperOverridesCount() : Int32;
	public import function GetAnimationWrapperOverridesItem( index : Int32 ) : CName;
	public import function AnimationWrapperOverridesContains( item : CName ) : Bool;
	public import function AllowBlendDuration() : Float;
	public import function TicketAcknowledgeTimeout() : Float;
	public import function AllowBlendPercCap() : Float;
	public import function SubActionsCanCompleteAction() : Bool;
	public import function FailIfAnimationNotStreamedIn() : Bool;
	public import function DisableAction() : Bool;
	public import function WaitForAnimationToLoad() : Bool;
	public import function DisableActionInMultiplayer() : Bool;
	public import function CompleteWithFailure() : Bool;
	public import function RevokingTicketCompletesAction() : Bool;
}

importonly class AIActionAND_Record extends AIActionSubCondition_Record
{
	public import function AND( out outList : array< weak< AIActionSubCondition_Record > > );
	public import function GetANDCount() : Int32;
	public import function GetANDItem( index : Int32 ) : weak< AIActionSubCondition_Record >;
	public import function GetANDItemHandle( index : Int32 ) : AIActionSubCondition_Record;
	public import function ANDContains( item : weak< AIActionSubCondition_Record > ) : Bool;
}

importonly class AIActionAnimData_Record extends TweakDBRecord
{
	public import function Direction() : weak< AIActionAnimDirection_Record >;
	public import function DirectionHandle() : AIActionAnimDirection_Record;
	public import function AnimSlot() : weak< AIActionAnimSlot_Record >;
	public import function AnimSlotHandle() : AIActionAnimSlot_Record;
	public import function AnimVariationSubAction() : weak< AISubAction_Record >;
	public import function AnimVariationSubActionHandle() : AISubAction_Record;
	public import function AnimFeature() : CName;
	public import function AnimVariation() : Int32;
	public import function WeaponOverride() : Int32;
	public import function MarginToPlayer() : Float;
	public import function RagdollOnDeath() : Bool;
	public import function UpdateMovePolicy() : Bool;
}

importonly class AIActionAnimDirection_Record extends TweakDBRecord
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function DirectionAngle() : Float;
}

importonly class AIActionAnimSlot_Record extends TweakDBRecord
{
	public import function StartupSlide() : weak< AIActionSlideData_Record >;
	public import function StartupSlideHandle() : AIActionSlideData_Record;
	public import function LoopSlide() : weak< AIActionSlideData_Record >;
	public import function LoopSlideHandle() : AIActionSlideData_Record;
	public import function RecoverySlide() : weak< AIActionSlideData_Record >;
	public import function RecoverySlideHandle() : AIActionSlideData_Record;
	public import function UsePoseMatching() : Bool;
	public import function UseRootMotion() : Bool;
	public import function ResetRagdollOnStart() : Bool;
	public import function UseDynamicObjectsCheck() : Bool;
}

importonly class AIActionChangeNPCState_Record extends TweakDBRecord
{
	public import function DefenseMode() : CName;
	public import function HitReactionMode() : CName;
	public import function HighLevelState() : CName;
	public import function LocomotionMode() : CName;
	public import function UpperBodyState() : CName;
	public import function StanceState() : CName;
}

importonly class AIActionCondition_Record extends TweakDBRecord
{
	public import function BlockCount() : weak< AIBlockCountCond_Record >;
	public import function BlockCountHandle() : AIBlockCountCond_Record;
	public import function Target() : weak< AITargetCond_Record >;
	public import function TargetHandle() : AITargetCond_Record;
	public import function FriendlyFire() : weak< AIFriendlyFireCond_Record >;
	public import function FriendlyFireHandle() : AIFriendlyFireCond_Record;
	public import function PreviousAttack() : weak< AIPreviousAttackCond_Record >;
	public import function PreviousAttackHandle() : AIPreviousAttackCond_Record;
	public import function CanThrow() : weak< AIThrowCond_Record >;
	public import function CanThrowHandle() : AIThrowCond_Record;
	public import function Condition() : weak< AIActionSubCondition_Record >;
	public import function ConditionHandle() : AIActionSubCondition_Record;
	public import function OptimalDistance() : weak< AIOptimalDistanceCond_Record >;
	public import function OptimalDistanceHandle() : AIOptimalDistanceCond_Record;
	public import function DodgeCount() : weak< AIDodgeCountCond_Record >;
	public import function DodgeCountHandle() : AIDodgeCountCond_Record;
	public import function WeaponLockedOnTarget() : weak< AIWeaponLockedOnTargetCond_Record >;
	public import function WeaponLockedOnTargetHandle() : AIWeaponLockedOnTargetCond_Record;
	public import function Cover() : weak< AICoverCond_Record >;
	public import function CoverHandle() : AICoverCond_Record;
	public import function GoToCover() : weak< AIGoToCoverCond_Record >;
	public import function GoToCoverHandle() : AIGoToCoverCond_Record;
	public import function ValidCover() : weak< AIValidCoversCond_Record >;
	public import function ValidCoverHandle() : AIValidCoversCond_Record;
	public import function Hit() : weak< AIHitCond_Record >;
	public import function HitHandle() : AIHitCond_Record;
	public import function Workspot() : weak< AIWorkspotCond_Record >;
	public import function WorkspotHandle() : AIWorkspotCond_Record;
	public import function Security() : weak< AISecurityCond_Record >;
	public import function SecurityHandle() : AISecurityCond_Record;
	public import function Weapon() : weak< AIHasWeapon_Record >;
	public import function WeaponHandle() : AIHasWeapon_Record;
	public import function NpcType() : weak< AINPCTypeCond_Record >;
	public import function NpcTypeHandle() : AINPCTypeCond_Record;
	public import function Lookat( out outList : array< weak< AILookAtCond_Record > > );
	public import function GetLookatCount() : Int32;
	public import function GetLookatItem( index : Int32 ) : weak< AILookAtCond_Record >;
	public import function GetLookatItemHandle( index : Int32 ) : AILookAtCond_Record;
	public import function LookatContains( item : weak< AILookAtCond_Record > ) : Bool;
	public import function WeakSpotAND( out outList : array< weak< AIWeakSpotCond_Record > > );
	public import function GetWeakSpotANDCount() : Int32;
	public import function GetWeakSpotANDItem( index : Int32 ) : weak< AIWeakSpotCond_Record >;
	public import function GetWeakSpotANDItemHandle( index : Int32 ) : AIWeakSpotCond_Record;
	public import function WeakSpotANDContains( item : weak< AIWeakSpotCond_Record > ) : Bool;
	public import function CommandAND( out outList : array< weak< AICommandCond_Record > > );
	public import function GetCommandANDCount() : Int32;
	public import function GetCommandANDItem( index : Int32 ) : weak< AICommandCond_Record >;
	public import function GetCommandANDItemHandle( index : Int32 ) : AICommandCond_Record;
	public import function CommandANDContains( item : weak< AICommandCond_Record > ) : Bool;
	public import function SlotOR( out outList : array< weak< AISlotCond_Record > > );
	public import function GetSlotORCount() : Int32;
	public import function GetSlotORItem( index : Int32 ) : weak< AISlotCond_Record >;
	public import function GetSlotORItemHandle( index : Int32 ) : AISlotCond_Record;
	public import function SlotORContains( item : weak< AISlotCond_Record > ) : Bool;
	public import function SpatialAND( out outList : array< weak< AISpatialCond_Record > > );
	public import function GetSpatialANDCount() : Int32;
	public import function GetSpatialANDItem( index : Int32 ) : weak< AISpatialCond_Record >;
	public import function GetSpatialANDItemHandle( index : Int32 ) : AISpatialCond_Record;
	public import function SpatialANDContains( item : weak< AISpatialCond_Record > ) : Bool;
	public import function SignalAND( out outList : array< weak< AISignalCond_Record > > );
	public import function GetSignalANDCount() : Int32;
	public import function GetSignalANDItem( index : Int32 ) : weak< AISignalCond_Record >;
	public import function GetSignalANDItemHandle( index : Int32 ) : AISignalCond_Record;
	public import function SignalANDContains( item : weak< AISignalCond_Record > ) : Bool;
	public import function Reaction( out outList : array< weak< AIReactionCond_Record > > );
	public import function GetReactionCount() : Int32;
	public import function GetReactionItem( index : Int32 ) : weak< AIReactionCond_Record >;
	public import function GetReactionItemHandle( index : Int32 ) : AIReactionCond_Record;
	public import function ReactionContains( item : weak< AIReactionCond_Record > ) : Bool;
	public import function StatPoolOR( out outList : array< weak< AIStatPoolCond_Record > > );
	public import function GetStatPoolORCount() : Int32;
	public import function GetStatPoolORItem( index : Int32 ) : weak< AIStatPoolCond_Record >;
	public import function GetStatPoolORItemHandle( index : Int32 ) : AIStatPoolCond_Record;
	public import function StatPoolORContains( item : weak< AIStatPoolCond_Record > ) : Bool;
	public import function StatusEffectOR( out outList : array< weak< AIStatusEffectCond_Record > > );
	public import function GetStatusEffectORCount() : Int32;
	public import function GetStatusEffectORItem( index : Int32 ) : weak< AIStatusEffectCond_Record >;
	public import function GetStatusEffectORItemHandle( index : Int32 ) : AIStatusEffectCond_Record;
	public import function StatusEffectORContains( item : weak< AIStatusEffectCond_Record > ) : Bool;
	public import function CalculateLineOfSightVector( out outList : array< weak< AICalculateLineOfSightVector_Record > > );
	public import function GetCalculateLineOfSightVectorCount() : Int32;
	public import function GetCalculateLineOfSightVectorItem( index : Int32 ) : weak< AICalculateLineOfSightVector_Record >;
	public import function GetCalculateLineOfSightVectorItemHandle( index : Int32 ) : AICalculateLineOfSightVector_Record;
	public import function CalculateLineOfSightVectorContains( item : weak< AICalculateLineOfSightVector_Record > ) : Bool;
	public import function StatPoolAND( out outList : array< weak< AIStatPoolCond_Record > > );
	public import function GetStatPoolANDCount() : Int32;
	public import function GetStatPoolANDItem( index : Int32 ) : weak< AIStatPoolCond_Record >;
	public import function GetStatPoolANDItemHandle( index : Int32 ) : AIStatPoolCond_Record;
	public import function StatPoolANDContains( item : weak< AIStatPoolCond_Record > ) : Bool;
	public import function SquadAND( out outList : array< weak< AISquadCond_Record > > );
	public import function GetSquadANDCount() : Int32;
	public import function GetSquadANDItem( index : Int32 ) : weak< AISquadCond_Record >;
	public import function GetSquadANDItemHandle( index : Int32 ) : AISquadCond_Record;
	public import function SquadANDContains( item : weak< AISquadCond_Record > ) : Bool;
	public import function InventoryOR( out outList : array< weak< AIItemCond_Record > > );
	public import function GetInventoryORCount() : Int32;
	public import function GetInventoryORItem( index : Int32 ) : weak< AIItemCond_Record >;
	public import function GetInventoryORItemHandle( index : Int32 ) : AIItemCond_Record;
	public import function InventoryORContains( item : weak< AIItemCond_Record > ) : Bool;
	public import function InventoryAND( out outList : array< weak< AIItemCond_Record > > );
	public import function GetInventoryANDCount() : Int32;
	public import function GetInventoryANDItem( index : Int32 ) : weak< AIItemCond_Record >;
	public import function GetInventoryANDItemHandle( index : Int32 ) : AIItemCond_Record;
	public import function InventoryANDContains( item : weak< AIItemCond_Record > ) : Bool;
	public import function InTacticPosition( out outList : array< weak< AIInTacticPositionCond_Record > > );
	public import function GetInTacticPositionCount() : Int32;
	public import function GetInTacticPositionItem( index : Int32 ) : weak< AIInTacticPositionCond_Record >;
	public import function GetInTacticPositionItemHandle( index : Int32 ) : AIInTacticPositionCond_Record;
	public import function InTacticPositionContains( item : weak< AIInTacticPositionCond_Record > ) : Bool;
	public import function WeakSpotOR( out outList : array< weak< AIWeakSpotCond_Record > > );
	public import function GetWeakSpotORCount() : Int32;
	public import function GetWeakSpotORItem( index : Int32 ) : weak< AIWeakSpotCond_Record >;
	public import function GetWeakSpotORItemHandle( index : Int32 ) : AIWeakSpotCond_Record;
	public import function WeakSpotORContains( item : weak< AIWeakSpotCond_Record > ) : Bool;
	public import function CalculatePath( out outList : array< weak< AICalculatePathCond_Record > > );
	public import function GetCalculatePathCount() : Int32;
	public import function GetCalculatePathItem( index : Int32 ) : weak< AICalculatePathCond_Record >;
	public import function GetCalculatePathItemHandle( index : Int32 ) : AICalculatePathCond_Record;
	public import function CalculatePathContains( item : weak< AICalculatePathCond_Record > ) : Bool;
	public import function AmmoCountAND( out outList : array< weak< AIAmmoCountCond_Record > > );
	public import function GetAmmoCountANDCount() : Int32;
	public import function GetAmmoCountANDItem( index : Int32 ) : weak< AIAmmoCountCond_Record >;
	public import function GetAmmoCountANDItemHandle( index : Int32 ) : AIAmmoCountCond_Record;
	public import function AmmoCountANDContains( item : weak< AIAmmoCountCond_Record > ) : Bool;
	public import function CommandOR( out outList : array< weak< AICommandCond_Record > > );
	public import function GetCommandORCount() : Int32;
	public import function GetCommandORItem( index : Int32 ) : weak< AICommandCond_Record >;
	public import function GetCommandORItemHandle( index : Int32 ) : AICommandCond_Record;
	public import function CommandORContains( item : weak< AICommandCond_Record > ) : Bool;
	public import function SquadOR( out outList : array< weak< AISquadCond_Record > > );
	public import function GetSquadORCount() : Int32;
	public import function GetSquadORItem( index : Int32 ) : weak< AISquadCond_Record >;
	public import function GetSquadORItemHandle( index : Int32 ) : AISquadCond_Record;
	public import function SquadORContains( item : weak< AISquadCond_Record > ) : Bool;
	public import function SlotAND( out outList : array< weak< AISlotCond_Record > > );
	public import function GetSlotANDCount() : Int32;
	public import function GetSlotANDItem( index : Int32 ) : weak< AISlotCond_Record >;
	public import function GetSlotANDItemHandle( index : Int32 ) : AISlotCond_Record;
	public import function SlotANDContains( item : weak< AISlotCond_Record > ) : Bool;
	public import function RestrictedMovementArea( out outList : array< weak< AIRestrictedMovementAreaCond_Record > > );
	public import function GetRestrictedMovementAreaCount() : Int32;
	public import function GetRestrictedMovementAreaItem( index : Int32 ) : weak< AIRestrictedMovementAreaCond_Record >;
	public import function GetRestrictedMovementAreaItemHandle( index : Int32 ) : AIRestrictedMovementAreaCond_Record;
	public import function RestrictedMovementAreaContains( item : weak< AIRestrictedMovementAreaCond_Record > ) : Bool;
	public import function AmmoCountOR( out outList : array< weak< AIAmmoCountCond_Record > > );
	public import function GetAmmoCountORCount() : Int32;
	public import function GetAmmoCountORItem( index : Int32 ) : weak< AIAmmoCountCond_Record >;
	public import function GetAmmoCountORItemHandle( index : Int32 ) : AIAmmoCountCond_Record;
	public import function AmmoCountORContains( item : weak< AIAmmoCountCond_Record > ) : Bool;
	public import function MovementOR( out outList : array< weak< AIMovementCond_Record > > );
	public import function GetMovementORCount() : Int32;
	public import function GetMovementORItem( index : Int32 ) : weak< AIMovementCond_Record >;
	public import function GetMovementORItemHandle( index : Int32 ) : AIMovementCond_Record;
	public import function MovementORContains( item : weak< AIMovementCond_Record > ) : Bool;
	public import function Cooldown( out outList : array< weak< AICooldownCond_Record > > );
	public import function GetCooldownCount() : Int32;
	public import function GetCooldownItem( index : Int32 ) : weak< AICooldownCond_Record >;
	public import function GetCooldownItemHandle( index : Int32 ) : AICooldownCond_Record;
	public import function CooldownContains( item : weak< AICooldownCond_Record > ) : Bool;
	public import function SignalOR( out outList : array< weak< AISignalCond_Record > > );
	public import function GetSignalORCount() : Int32;
	public import function GetSignalORItem( index : Int32 ) : weak< AISignalCond_Record >;
	public import function GetSignalORItemHandle( index : Int32 ) : AISignalCond_Record;
	public import function SignalORContains( item : weak< AISignalCond_Record > ) : Bool;
	public import function VehicleOR( out outList : array< weak< AIVehicleCond_Record > > );
	public import function GetVehicleORCount() : Int32;
	public import function GetVehicleORItem( index : Int32 ) : weak< AIVehicleCond_Record >;
	public import function GetVehicleORItemHandle( index : Int32 ) : AIVehicleCond_Record;
	public import function VehicleORContains( item : weak< AIVehicleCond_Record > ) : Bool;
	public import function SpatialOR( out outList : array< weak< AISpatialCond_Record > > );
	public import function GetSpatialORCount() : Int32;
	public import function GetSpatialORItem( index : Int32 ) : weak< AISpatialCond_Record >;
	public import function GetSpatialORItemHandle( index : Int32 ) : AISpatialCond_Record;
	public import function SpatialORContains( item : weak< AISpatialCond_Record > ) : Bool;
	public import function MovementAND( out outList : array< weak< AIMovementCond_Record > > );
	public import function GetMovementANDCount() : Int32;
	public import function GetMovementANDItem( index : Int32 ) : weak< AIMovementCond_Record >;
	public import function GetMovementANDItemHandle( index : Int32 ) : AIMovementCond_Record;
	public import function MovementANDContains( item : weak< AIMovementCond_Record > ) : Bool;
	public import function StatusEffectAND( out outList : array< weak< AIStatusEffectCond_Record > > );
	public import function GetStatusEffectANDCount() : Int32;
	public import function GetStatusEffectANDItem( index : Int32 ) : weak< AIStatusEffectCond_Record >;
	public import function GetStatusEffectANDItemHandle( index : Int32 ) : AIStatusEffectCond_Record;
	public import function StatusEffectANDContains( item : weak< AIStatusEffectCond_Record > ) : Bool;
	public import function VehicleAND( out outList : array< weak< AIVehicleCond_Record > > );
	public import function GetVehicleANDCount() : Int32;
	public import function GetVehicleANDItem( index : Int32 ) : weak< AIVehicleCond_Record >;
	public import function GetVehicleANDItemHandle( index : Int32 ) : AIVehicleCond_Record;
	public import function VehicleANDContains( item : weak< AIVehicleCond_Record > ) : Bool;
	public import function Ability( out outList : array< weak< AIAbilityCond_Record > > );
	public import function GetAbilityCount() : Int32;
	public import function GetAbilityItem( index : Int32 ) : weak< AIAbilityCond_Record >;
	public import function GetAbilityItemHandle( index : Int32 ) : AIAbilityCond_Record;
	public import function AbilityContains( item : weak< AIAbilityCond_Record > ) : Bool;
	public import function State( out outList : array< weak< AIStateCond_Record > > );
	public import function GetStateCount() : Int32;
	public import function GetStateItem( index : Int32 ) : weak< AIStateCond_Record >;
	public import function GetStateItemHandle( index : Int32 ) : AIStateCond_Record;
	public import function StateContains( item : weak< AIStateCond_Record > ) : Bool;
	public import function Tresspassing( out outList : array< weak< AITresspassingCond_Record > > );
	public import function GetTresspassingCount() : Int32;
	public import function GetTresspassingItem( index : Int32 ) : weak< AITresspassingCond_Record >;
	public import function GetTresspassingItemHandle( index : Int32 ) : AITresspassingCond_Record;
	public import function TresspassingContains( item : weak< AITresspassingCond_Record > ) : Bool;
}

importonly class AIActionCooldown_Record extends TweakDBRecord
{
	public import function ActivationCondition( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetActivationConditionCount() : Int32;
	public import function GetActivationConditionItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetActivationConditionItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function ActivationConditionContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function Name() : CName;
	public import function Duration() : Float;
}

importonly class AIActionLookAtData_Record extends TweakDBRecord
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function ActivationCondition() : weak< AIActionCondition_Record >;
	public import function ActivationConditionHandle() : AIActionCondition_Record;
	public import function Preset() : weak< LookAtPreset_Record >;
	public import function PresetHandle() : LookAtPreset_Record;
	public import function Offset() : Vector3;
	public import function TimeDelay() : Float;
}

importonly class AIActionOR_Record extends AIActionSubCondition_Record
{
	public import function OR( out outList : array< weak< AIActionSubCondition_Record > > );
	public import function GetORCount() : Int32;
	public import function GetORItem( index : Int32 ) : weak< AIActionSubCondition_Record >;
	public import function GetORItemHandle( index : Int32 ) : AIActionSubCondition_Record;
	public import function ORContains( item : weak< AIActionSubCondition_Record > ) : Bool;
}

importonly class AIActionPhase_Record extends TweakDBRecord
{
	public import function MovePolicy() : weak< MovementPolicy_Record >;
	public import function MovePolicyHandle() : MovementPolicy_Record;
	public import function ChangeNPCState() : weak< AIActionChangeNPCState_Record >;
	public import function ChangeNPCStateHandle() : AIActionChangeNPCState_Record;
	public import function DynamicDuration() : weak< AISubAction_Record >;
	public import function DynamicDurationHandle() : AISubAction_Record;
	public import function ToNextPhaseCondition( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetToNextPhaseConditionCount() : Int32;
	public import function GetToNextPhaseConditionItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetToNextPhaseConditionItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function ToNextPhaseConditionContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function NotRepeatPhaseCondition( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetNotRepeatPhaseConditionCount() : Int32;
	public import function GetNotRepeatPhaseConditionItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetNotRepeatPhaseConditionItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function NotRepeatPhaseConditionContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function AnimationDuration() : Float;
	public import function ToNextPhaseConditionCheckInterval() : Float;
	public import function Repeat() : Int32;
	public import function ConditionSuccessDuration() : Float;
	public import function Duration() : Float;
	public import function MaxDuration() : Float;
	public import function CompleteActionWithFailureOnCondition() : Bool;
	public import function UseDurationFromAnimSlot() : Bool;
	public import function ForceZeroUpdateInterval() : Bool;
	public import function DontStopInfiniteOnSubActionsCompletion() : Bool;
}

importonly class AIActionSecurityAreaType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAIActionSecurityAreaType;
}

importonly class AIActionSecurityNotificationType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAIActionSecurityNotificationType;
}

importonly class AIActionSelector_Record extends AINode_Record
{
	public import function DefaultAction() : weak< AIAction_Record >;
	public import function DefaultActionHandle() : AIAction_Record;
	public import function Actions( out outList : array< weak< AIAction_Record > > );
	public import function GetActionsCount() : Int32;
	public import function GetActionsItem( index : Int32 ) : weak< AIAction_Record >;
	public import function GetActionsItemHandle( index : Int32 ) : AIAction_Record;
	public import function ActionsContains( item : weak< AIAction_Record > ) : Bool;
	public import function DisableActionsLimit() : Bool;
	public import function FailOnNodeActivationConditionFailure() : Bool;
}

importonly class AIActionSequence_Record extends AINode_Record
{
	public import function Actions( out outList : array< weak< AIAction_Record > > );
	public import function GetActionsCount() : Int32;
	public import function GetActionsItem( index : Int32 ) : weak< AIAction_Record >;
	public import function GetActionsItemHandle( index : Int32 ) : AIAction_Record;
	public import function ActionsContains( item : weak< AIAction_Record > ) : Bool;
	public import function HasMemory() : Bool;
	public import function DisableActionsLimit() : Bool;
	public import function FailOnNodeActivationConditionFailure() : Bool;
}

importonly class AIActionSlideData_Record extends TweakDBRecord
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function OffsetAroundTarget() : Float;
	public import function FinalRotationAngle() : Float;
	public import function PositionSpeed() : Float;
	public import function Distance() : Float;
	public import function DirectionAngle() : Float;
	public import function OffsetToTarget() : Float;
	public import function SlideStartDelay() : Float;
	public import function RotationSpeed() : Float;
	public import function Duration() : Float;
	public import function PositionPredictionTime() : Float;
	public import function ZAlignmentCollisionThreshold() : Float;
	public import function UsePositionSlide() : Bool;
	public import function DisablePositionSlideAgainstNpc() : Bool;
	public import function OverrideOffsetToTargetFromWeapon() : Bool;
	public import function UseRotationSlide() : Bool;
}

importonly class AIActionSmartComposite_Record extends AIRecord_Record
{
	public import function Type() : weak< AISmartCompositeType_Record >;
	public import function TypeHandle() : AISmartCompositeType_Record;
	public import function GracefulInterruptionCondition( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetGracefulInterruptionConditionCount() : Int32;
	public import function GetGracefulInterruptionConditionItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetGracefulInterruptionConditionItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function GracefulInterruptionConditionContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function Nodes( out outList : array< weak< AINode_Record > > );
	public import function GetNodesCount() : Int32;
	public import function GetNodesItem( index : Int32 ) : weak< AINode_Record >;
	public import function GetNodesItemHandle( index : Int32 ) : AINode_Record;
	public import function NodesContains( item : weak< AINode_Record > ) : Bool;
	public import function GracefulInterruptionConditionCheckInterval() : Float;
	public import function Repeat() : Int32;
	public import function ConditionSuccessDuration() : Float;
	public import function FailOnNodeActivationConditionFailure() : Bool;
	public import function DisableActionsLimit() : Bool;
}

importonly class AIActionSubCondition_Record extends TweakDBRecord
{
	public import function Invert() : Bool;
}

importonly class AIActionTarget_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function TrackingMode() : weak< TrackingMode_Record >;
	public import function TrackingModeHandle() : TrackingMode_Record;
	public import function BehaviorArgumentName() : CName;
	public import function EnumName() : CName;
	public import function TargetSlot() : CName;
	public import function IsObject() : Bool;
	public import function IsCoverID() : Bool;
	public import function IsPosition() : Bool;
	public import function Type() : gamedataAIActionTarget;
}

importonly class AIActionTicket_Record extends AITicket_Record
{
}

importonly class AIActionType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAIActionType;
}

importonly class AIAdditionalTraceType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAIAdditionalTraceType;
}

importonly class AIAffiliationCond_Record extends AIActionSubCondition_Record
{
	public import function Affiliation() : weak< Affiliation_Record >;
	public import function AffiliationHandle() : Affiliation_Record;
}

importonly class AIAmmoCountCond_Record extends AIActionSubCondition_Record
{
	public import function WeaponSlot() : weak< AttachmentSlot_Record >;
	public import function WeaponSlotHandle() : AttachmentSlot_Record;
	public import function Percentage() : Vector2;
	public import function Max() : Int32;
	public import function Min() : Int32;
}

importonly class AIAssignedVehicleCanReachTargetCond_Record extends AIActionSubCondition_Record
{
	public import function Vehicle() : weak< AIActionTarget_Record >;
	public import function VehicleHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Duration() : Float;
}

importonly class AIAssignedVehicleInPanicDriving_Record extends AIActionSubCondition_Record
{
	public import function Vehicle() : weak< AIActionTarget_Record >;
	public import function VehicleHandle() : AIActionTarget_Record;
}

importonly class AIAssignedVehicleInRace_Record extends AIActionSubCondition_Record
{
	public import function Vehicle() : weak< AIActionTarget_Record >;
	public import function VehicleHandle() : AIActionTarget_Record;
}

importonly class AIBlockCountCond_Record extends AIActionSubCondition_Record
{
	public import function OwnerAttackParriedCount() : Int32;
	public import function MaxParryCount() : Int32;
	public import function MaxBlockCount() : Int32;
	public import function OwnerAttackBlockedCount() : Int32;
	public import function MinParryCount() : Int32;
	public import function MinBlockCount() : Int32;
}

importonly class AICalculateLineOfSightVector_Record extends AIActionSubCondition_Record
{
	public import function StartPosition() : weak< AIActionTarget_Record >;
	public import function StartPositionHandle() : AIActionTarget_Record;
	public import function EndPosition() : weak< AIActionTarget_Record >;
	public import function EndPositionHandle() : AIActionTarget_Record;
	public import function StartPositionOffset() : Vector3;
	public import function EndPositionOffset() : Vector3;
	public import function IgnoreNonPenetrableObj() : Bool;
}

importonly class AICalculatePathCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function AllowedOffMeshTags() : array< CName >;
	public import function GetAllowedOffMeshTagsCount() : Int32;
	public import function GetAllowedOffMeshTagsItem( index : Int32 ) : CName;
	public import function AllowedOffMeshTagsContains( item : CName ) : Bool;
	public import function StartPositionOffset() : Vector3;
	public import function DirectionAngle() : Float;
	public import function Distance() : Float;
	public import function Tolerance() : Float;
	public import function CheckStraightPath() : Bool;
	public import function CheckDynamicObstacle() : Bool;
}

importonly class AICanShootInCarChaseCond_Record extends AIActionSubCondition_Record
{
}

importonly class AICommand_Record extends TweakDBRecord
{
	public import function HasCommands() : array< CName >;
	public import function GetHasCommandsCount() : Int32;
	public import function GetHasCommandsItem( index : Int32 ) : CName;
	public import function HasCommandsContains( item : CName ) : Bool;
	public import function HasNewOrOverridenCommands() : array< CName >;
	public import function GetHasNewOrOverridenCommandsCount() : Int32;
	public import function GetHasNewOrOverridenCommandsItem( index : Int32 ) : CName;
	public import function HasNewOrOverridenCommandsContains( item : CName ) : Bool;
}

importonly class AICommandCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function HasCommands() : array< CName >;
	public import function GetHasCommandsCount() : Int32;
	public import function GetHasCommandsItem( index : Int32 ) : CName;
	public import function HasCommandsContains( item : CName ) : Bool;
	public import function HasNewOrOverridenCommands() : array< CName >;
	public import function GetHasNewOrOverridenCommandsCount() : Int32;
	public import function GetHasNewOrOverridenCommandsItem( index : Int32 ) : CName;
	public import function HasNewOrOverridenCommandsContains( item : CName ) : Bool;
}

importonly class AIComparison_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function Type() : gamedataAIComparison;
}

importonly class AICooldownCond_Record extends AIActionSubCondition_Record
{
	public import function Cooldowns( out outList : array< weak< AIActionCooldown_Record > > );
	public import function GetCooldownsCount() : Int32;
	public import function GetCooldownsItem( index : Int32 ) : weak< AIActionCooldown_Record >;
	public import function GetCooldownsItemHandle( index : Int32 ) : AIActionCooldown_Record;
	public import function CooldownsContains( item : weak< AIActionCooldown_Record > ) : Bool;
}

importonly class AICoverCond_Record extends AIActionSubCondition_Record
{
	public import function Cover() : weak< AIActionTarget_Record >;
	public import function CoverHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function DesiredCover() : weak< AIActionTarget_Record >;
	public import function DesiredCoverHandle() : AIActionTarget_Record;
	public import function Owner() : weak< AIActionTarget_Record >;
	public import function OwnerHandle() : AIActionTarget_Record;
	public import function CheckChosenExposureMethod() : array< CName >;
	public import function GetCheckChosenExposureMethodCount() : Int32;
	public import function GetCheckChosenExposureMethodItem( index : Int32 ) : CName;
	public import function CheckChosenExposureMethodContains( item : CName ) : Bool;
	public import function CoverExposureMethods() : array< CName >;
	public import function GetCoverExposureMethodsCount() : Int32;
	public import function GetCoverExposureMethodsItem( index : Int32 ) : CName;
	public import function CoverExposureMethodsContains( item : CName ) : Bool;
	public import function MaxCoverToTargetAngle() : Float;
	public import function IsOwnerCrouching() : Int32;
	public import function HasAnyLastAvailableExposureMethods() : Int32;
	public import function IsProtectingHorizontallyAgainstTarget() : Int32;
	public import function DesiredCoverChanged() : Int32;
	public import function PredictionTime() : Float;
	public import function IsOwnerExposed() : Int32;
	public import function MinCoverHealth() : Float;
	public import function CoverType() : Int32;
	public import function CheckIfCoverTransitionRequired() : Bool;
}

importonly class AIDifficulty_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function Type() : gamedataAIDifficulty;
}

importonly class AIDirectorEntryStartType_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function Type() : gamedataAIDirectorEntryStartType;
}

importonly class AIDirectorSchedule_Record extends TweakDBRecord
{
	public import function Entries( out outList : array< weak< AIDirectorScheduleEntry_Record > > );
	public import function GetEntriesCount() : Int32;
	public import function GetEntriesItem( index : Int32 ) : weak< AIDirectorScheduleEntry_Record >;
	public import function GetEntriesItemHandle( index : Int32 ) : AIDirectorScheduleEntry_Record;
	public import function EntriesContains( item : weak< AIDirectorScheduleEntry_Record > ) : Bool;
}

importonly class AIDirectorScheduleEntry_Record extends TweakDBRecord
{
	public import function EntryStartType() : weak< AIDirectorEntryStartType_Record >;
	public import function EntryStartTypeHandle() : AIDirectorEntryStartType_Record;
	public import function Plans( out outList : array< weak< AIDirectorSchedulePlan_Record > > );
	public import function GetPlansCount() : Int32;
	public import function GetPlansItem( index : Int32 ) : weak< AIDirectorSchedulePlan_Record >;
	public import function GetPlansItemHandle( index : Int32 ) : AIDirectorSchedulePlan_Record;
	public import function PlansContains( item : weak< AIDirectorSchedulePlan_Record > ) : Bool;
	public import function Duration() : Float;
	public import function TensionDelta() : Float;
	public import function KillsLimit() : Int32;
}

importonly class AIDirectorSchedulePlan_Record extends TweakDBRecord
{
	public import function SpawningDesc() : weak< AIDirectorScheduleSpawningDesc_Record >;
	public import function SpawningDescHandle() : AIDirectorScheduleSpawningDesc_Record;
	public import function MinTensionToPerform() : Float;
}

importonly class AIDirectorSchedulePlanEnemyEntry_Record extends TweakDBRecord
{
	public import function Character() : weak< Character_Record >;
	public import function CharacterHandle() : Character_Record;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function SpawnChanceFactor() : Float;
	public import function MaxAmountConcurrently() : Int32;
}

importonly class AIDirectorScheduleSpawningDesc_Record extends TweakDBRecord
{
	public import function Entries( out outList : array< weak< AIDirectorSchedulePlanEnemyEntry_Record > > );
	public import function GetEntriesCount() : Int32;
	public import function GetEntriesItem( index : Int32 ) : weak< AIDirectorSchedulePlanEnemyEntry_Record >;
	public import function GetEntriesItemHandle( index : Int32 ) : AIDirectorSchedulePlanEnemyEntry_Record;
	public import function EntriesContains( item : weak< AIDirectorSchedulePlanEnemyEntry_Record > ) : Bool;
	public import function SpawningBigDistance() : Float;
	public import function SpawningAngle() : Float;
	public import function EnemiesAmount() : Int32;
	public import function SpawningMinDistance() : Float;
}

importonly class AIDodgeCountCond_Record extends AIActionSubCondition_Record
{
	public import function MinDodgeCount() : Int32;
	public import function MaxDodgeCount() : Int32;
	public import function OwnerAttackDodgedCount() : Int32;
}

importonly class AIDriverCond_Record extends AIActionSubCondition_Record
{
	public import function Driver() : weak< AIActionTarget_Record >;
	public import function DriverHandle() : AIActionTarget_Record;
}

importonly class AIEverPerformedChase_Record extends AIActionSubCondition_Record
{
	public import function Vehicle() : weak< AIActionTarget_Record >;
	public import function VehicleHandle() : AIActionTarget_Record;
}

importonly class AIExposureMethodType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function Priority() : array< Int32 >;
	public import function GetPriorityCount() : Int32;
	public import function GetPriorityItem( index : Int32 ) : Int32;
	public import function PriorityContains( item : Int32 ) : Bool;
	public import function EnumName() : CName;
	public import function Type() : gamedataAIExposureMethodType;
}

importonly class AIExtendTargetCirclingCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function DestinationTarget() : weak< AIActionTarget_Record >;
	public import function DestinationTargetHandle() : AIActionTarget_Record;
	public import function SpreadIncreaseAngle() : Float;
}

importonly class AIFriendlyFireCond_Record extends AIActionSubCondition_Record
{
	public import function CheckPlayer() : Bool;
}

importonly class AIGameDifficultyCond_Record extends AIActionSubCondition_Record
{
	public import function ComparisonType() : CName;
	public import function ComparedDifficulty() : Int32;
}

importonly class AIGoToCoverCond_Record extends AIActionSubCondition_Record
{
	public import function Cover() : weak< AIActionTarget_Record >;
	public import function CoverHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function DesiredCover() : weak< AIActionTarget_Record >;
	public import function DesiredCoverHandle() : AIActionTarget_Record;
	public import function IsCoverSelected() : Int32;
	public import function DesiredCoverChanged() : Int32;
	public import function IsEnteringOrLeavingCover() : Int32;
}

importonly class AIHasWeapon_Record extends AIActionSubCondition_Record
{
	public import function ItemType( out outList : array< weak< ItemType_Record > > );
	public import function GetItemTypeCount() : Int32;
	public import function GetItemTypeItem( index : Int32 ) : weak< ItemType_Record >;
	public import function GetItemTypeItemHandle( index : Int32 ) : ItemType_Record;
	public import function ItemTypeContains( item : weak< ItemType_Record > ) : Bool;
	public import function ItemCategory( out outList : array< weak< ItemCategory_Record > > );
	public import function GetItemCategoryCount() : Int32;
	public import function GetItemCategoryItem( index : Int32 ) : weak< ItemCategory_Record >;
	public import function GetItemCategoryItemHandle( index : Int32 ) : ItemCategory_Record;
	public import function ItemCategoryContains( item : weak< ItemCategory_Record > ) : Bool;
	public import function ItemTag() : CName;
}

importonly class AIHitCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function AttackTag() : CName;
	public import function MinHitSeverity() : Int32;
	public import function MaxHitSeverity() : Int32;
	public import function TargetHitCount() : Int32;
	public import function HitTimeout() : Float;
	public import function HitDirection() : Int32;
	public import function CumulatedDamageThreshold() : Int32;
}

importonly class AIInArmedVehicleCond_Record extends AIActionSubCondition_Record
{
}

importonly class AIInTacticPositionCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Tactics( out outList : array< weak< AITacticType_Record > > );
	public import function GetTacticsCount() : Int32;
	public import function GetTacticsItem( index : Int32 ) : weak< AITacticType_Record >;
	public import function GetTacticsItemHandle( index : Int32 ) : AITacticType_Record;
	public import function TacticsContains( item : weak< AITacticType_Record > ) : Bool;
}

importonly class AIIsFromDynamicSpawnSystem_Record extends AIActionSubCondition_Record
{
}

importonly class AIIsFromPreventionSystem_Record extends AIActionSubCondition_Record
{
}

importonly class AIIsHeatStage5Active_Record extends AIActionSubCondition_Record
{
}

importonly class AIIsInActiveCameraCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Height() : Float;
	public import function Radius() : Float;
}

importonly class AIIsOnNavmeshCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Radius() : Float;
}

importonly class AIIsShootingBlockedFromPrevention_Record extends AIActionSubCondition_Record
{
}

importonly class AIItemCond_Record extends AIActionSubCondition_Record
{
	public import function ItemCategory() : weak< ItemCategory_Record >;
	public import function ItemCategoryHandle() : ItemCategory_Record;
	public import function ItemType() : weak< ItemType_Record >;
	public import function ItemTypeHandle() : ItemType_Record;
	public import function ItemID() : weak< Item_Record >;
	public import function ItemIDHandle() : Item_Record;
	public import function Evolution() : weak< WeaponEvolution_Record >;
	public import function EvolutionHandle() : WeaponEvolution_Record;
	public import function TriggerModes( out outList : array< weak< TriggerMode_Record > > );
	public import function GetTriggerModesCount() : Int32;
	public import function GetTriggerModesItem( index : Int32 ) : weak< TriggerMode_Record >;
	public import function GetTriggerModesItemHandle( index : Int32 ) : TriggerMode_Record;
	public import function TriggerModesContains( item : weak< TriggerMode_Record > ) : Bool;
	public import function ItemTag() : CName;
	public import function EquipmentGroup() : CName;
	public import function CheckAllItemsInEquipmentGroup() : Bool;
}

importonly class AILoSPositionCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function MaxRadiusXY() : Float;
	public import function Type() : Int32;
	public import function MaxRadiusZ() : Float;
	public import function MaxNotFoundTime() : Float;
}

importonly class AILookAtCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function RightArmLookAtActive() : Int32;
}

importonly class AIMovementCond_Record extends AIActionSubCondition_Record
{
	public import function Destination() : weak< AIActionTarget_Record >;
	public import function DestinationHandle() : AIActionTarget_Record;
	public import function MovementType() : CName;
	public import function MoveLocomotionAction() : CName;
	public import function OffMeshLinkType() : CName;
	public import function SpatialHintMults() : Vector3;
	public import function Slope() : Vector2;
	public import function DistanceToDestination() : Vector2;
	public import function ConstrainedByRestrictedArea() : Int32;
	public import function LineOfSightFailed() : Int32;
	public import function IsUsingOffMeshLink() : Int32;
	public import function IsPauseByDynamicCollision() : Int32;
	public import function PathFindingFailed() : Int32;
	public import function IsEvaluated() : Int32;
	public import function IsMoving() : Int32;
	public import function IsDestinationCalculated() : Int32;
	public import function IsDestinationChanged() : Int32;
}

importonly class AIMovingInCirclesCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Range() : Float;
	public import function Time() : Float;
}

importonly class AINPCDifficultyCond_Record extends AIActionSubCondition_Record
{
	public import function ComparisonType() : CName;
	public import function ComparedDifficulty() : Int32;
}

importonly class AINPCRarityCond_Record extends AIActionSubCondition_Record
{
	public import function Rarity() : String;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
}

importonly class AINPCTypeCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function VisualTags() : array< CName >;
	public import function GetVisualTagsCount() : Int32;
	public import function GetVisualTagsItem( index : Int32 ) : CName;
	public import function VisualTagsContains( item : CName ) : Bool;
	public import function AllowedNPCTypes( out outList : array< weak< NPCType_Record > > );
	public import function GetAllowedNPCTypesCount() : Int32;
	public import function GetAllowedNPCTypesItem( index : Int32 ) : weak< NPCType_Record >;
	public import function GetAllowedNPCTypesItemHandle( index : Int32 ) : NPCType_Record;
	public import function AllowedNPCTypesContains( item : weak< NPCType_Record > ) : Bool;
	public import function DeviceState() : Int32;
	public import function IsFollower() : Int32;
}

importonly class AINode_Record extends AIRecord_Record
{
	public import function ActivationCondition() : weak< AIActionCondition_Record >;
	public import function ActivationConditionHandle() : AIActionCondition_Record;
	public import function ActivateCondition() : weak< AIActionAND_Record >;
	public import function ActivateConditionHandle() : AIActionAND_Record;
	public import function MinLOD() : Int32;
	public import function IsVirtual() : Bool;
}

importonly class AINodeMap_Record extends TweakDBRecord
{
	public import function Map( out outList : array< weak< AINodeMapField_Record > > );
	public import function GetMapCount() : Int32;
	public import function GetMapItem( index : Int32 ) : weak< AINodeMapField_Record >;
	public import function GetMapItemHandle( index : Int32 ) : AINodeMapField_Record;
	public import function MapContains( item : weak< AINodeMapField_Record > ) : Bool;
}

importonly class AINodeMapField_Record extends TweakDBRecord
{
	public import function Node() : weak< AIRecord_Record >;
	public import function NodeHandle() : AIRecord_Record;
	public import function IsOverriddenBy() : weak< AIRecord_Record >;
	public import function IsOverriddenByHandle() : AIRecord_Record;
	public import function ForLOD() : Int32;
}

importonly class AIOptimalDistanceCond_Record extends AIActionSubCondition_Record
{
	public import function Source() : weak< AIActionTarget_Record >;
	public import function SourceHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function CheckRings( out outList : array< weak< AIRingType_Record > > );
	public import function GetCheckRingsCount() : Int32;
	public import function GetCheckRingsItem( index : Int32 ) : weak< AIRingType_Record >;
	public import function GetCheckRingsItemHandle( index : Int32 ) : AIRingType_Record;
	public import function CheckRingsContains( item : weak< AIRingType_Record > ) : Bool;
	public import function PredictionTime() : Float;
	public import function DistanceMult() : Float;
	public import function ToleranceOffset() : Float;
	public import function DistanceOffset() : Float;
	public import function ToleranceMult() : Float;
	public import function FailWhenCloserThanCurrentRing() : Bool;
	public import function FailWhenFurtherThantCurrentRing() : Bool;
}

importonly class AIPattern_Record extends TweakDBRecord
{
	public import function ActivationConditions( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetActivationConditionsCount() : Int32;
	public import function GetActivationConditionsItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetActivationConditionsItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function ActivationConditionsContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function Delays( out outList : array< weak< AIPatternDelay_Record > > );
	public import function GetDelaysCount() : Int32;
	public import function GetDelaysItem( index : Int32 ) : weak< AIPatternDelay_Record >;
	public import function GetDelaysItemHandle( index : Int32 ) : AIPatternDelay_Record;
	public import function DelaysContains( item : weak< AIPatternDelay_Record > ) : Bool;
	public import function PatternSize() : Int32;
}

importonly class AIPatternDelay_Record extends TweakDBRecord
{
	public import function ShotNumber() : Int32;
	public import function Delay() : Float;
}

importonly class AIPatternsPackage_Record extends TweakDBRecord
{
	public import function ActivationConditions( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetActivationConditionsCount() : Int32;
	public import function GetActivationConditionsItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetActivationConditionsItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function ActivationConditionsContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function Patterns( out outList : array< weak< AIPattern_Record > > );
	public import function GetPatternsCount() : Int32;
	public import function GetPatternsItem( index : Int32 ) : weak< AIPattern_Record >;
	public import function GetPatternsItemHandle( index : Int32 ) : AIPattern_Record;
	public import function PatternsContains( item : weak< AIPattern_Record > ) : Bool;
}

importonly class AIPercentageChanceCond_Record extends AIActionSubCondition_Record
{
	public import function SuccessProbability() : Int32;
}

importonly class AIPreviousAttackCond_Record extends AIActionSubCondition_Record
{
	public import function PreviousAttackName() : array< CName >;
	public import function GetPreviousAttackNameCount() : Int32;
	public import function GetPreviousAttackNameItem( index : Int32 ) : CName;
	public import function PreviousAttackNameContains( item : CName ) : Bool;
	public import function TimeWindow() : Float;
	public import function PreviousAttackDirection() : Int32;
}

importonly class AIReactionCond_Record extends AIActionSubCondition_Record
{
	public import function Preset() : weak< ReactionPreset_Record >;
	public import function PresetHandle() : ReactionPreset_Record;
	public import function ThresholdValue() : weak< StatPool_Record >;
	public import function ThresholdValueHandle() : StatPool_Record;
	public import function StimType( out outList : array< weak< StimType_Record > > );
	public import function GetStimTypeCount() : Int32;
	public import function GetStimTypeItem( index : Int32 ) : weak< StimType_Record >;
	public import function GetStimTypeItemHandle( index : Int32 ) : StimType_Record;
	public import function StimTypeContains( item : weak< StimType_Record > ) : Bool;
	public import function ReactionBehaviorName() : CName;
	public import function ValidStimPosition() : Bool;
	public import function InvestigateController() : Bool;
}

importonly class AIRecord_Record extends TweakDBRecord
{
}

importonly class AIRestrictedMovementAreaCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
}

importonly class AIRingTicket_Record extends AITicket_Record
{
	public import function RingType() : weak< AIRingType_Record >;
	public import function RingTypeHandle() : AIRingType_Record;
}

importonly class AIRingType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Distance() : Float;
	public import function Tolerance() : Float;
	public import function Type() : gamedataAIRingType;
}

importonly class AIRole_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function RolePackage() : weak< GameplayLogicPackage_Record >;
	public import function RolePackageHandle() : GameplayLogicPackage_Record;
	public import function EnumName() : CName;
	public import function Type() : gamedataAIRole;
}

importonly class AISectorType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
}

importonly class AISecurityCond_Record extends AIActionSubCondition_Record
{
	public import function AreaType() : weak< AIActionSecurityAreaType_Record >;
	public import function AreaTypeHandle() : AIActionSecurityAreaType_Record;
	public import function IsConnected() : Int32;
}

importonly class AISignalCond_Record extends AIActionSubCondition_Record
{
	public import function Name() : CName;
}

importonly class AISlotCond_Record extends AIItemCond_Record
{
	public import function RequestedTriggerModes() : weak< TriggerMode_Record >;
	public import function RequestedTriggerModesHandle() : TriggerMode_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Slot() : weak< AttachmentSlot_Record >;
	public import function SlotHandle() : AttachmentSlot_Record;
	public import function CheckIfEmptySlotIsSpawningItem() : Int32;
}

importonly class AISmartCompositeType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function HasMemory() : Bool;
	public import function IncrementIteratorOnDeactivation() : Bool;
	public import function RandomizeIteratorOnReset() : Bool;
	public import function Type() : gamedataAISmartCompositeType;
}

importonly class AISpatialCond_Record extends AIActionSubCondition_Record
{
	public import function TargetOpt() : weak< AIActionTarget_Record >;
	public import function TargetOptHandle() : AIActionTarget_Record;
	public import function Source() : weak< AIActionTarget_Record >;
	public import function SourceHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function SpatialHintMults() : Vector3;
	public import function ZDiff() : Vector2;
	public import function ConeAngle() : Vector2;
	public import function Distance() : Vector2;
	public import function PredictionTime() : Float;
	public import function AngleDirection() : Int32;
	public import function ConsiderDirectionsOnly() : Bool;
	public import function UseTargetPOV() : Bool;
}

importonly class AISquadANDCondition_Record extends AITicketCheck_Record
{
	public import function AND( out outList : array< weak< AITicketCheck_Record > > );
	public import function GetANDCount() : Int32;
	public import function GetANDItem( index : Int32 ) : weak< AITicketCheck_Record >;
	public import function GetANDItemHandle( index : Int32 ) : AITicketCheck_Record;
	public import function ANDContains( item : weak< AITicketCheck_Record > ) : Bool;
}

importonly class AISquadAvoidLastFilter_Record extends AITicketFilter_Record
{
}

importonly class AISquadClosestToSectorCheck_Record extends AISquadDistanceRelationToSectorCheck_Record
{
}

importonly class AISquadClosestToTargetCheck_Record extends AISquadDistanceRelationToTargetCheck_Record
{
}

importonly class AISquadCond_Record extends AIActionSubCondition_Record
{
	public import function HasTickets( out outList : array< weak< AITicketType_Record > > );
	public import function GetHasTicketsCount() : Int32;
	public import function GetHasTicketsItem( index : Int32 ) : weak< AITicketType_Record >;
	public import function GetHasTicketsItemHandle( index : Int32 ) : AITicketType_Record;
	public import function HasTicketsContains( item : weak< AITicketType_Record > ) : Bool;
	public import function TicketsConditionCheck( out outList : array< weak< AITicketType_Record > > );
	public import function GetTicketsConditionCheckCount() : Int32;
	public import function GetTicketsConditionCheckItem( index : Int32 ) : weak< AITicketType_Record >;
	public import function GetTicketsConditionCheckItemHandle( index : Int32 ) : AITicketType_Record;
	public import function TicketsConditionCheckContains( item : weak< AITicketType_Record > ) : Bool;
}

importonly class AISquadContainsSelfCheck_Record extends AITicketCheck_Record
{
}

importonly class AISquadDistanceRelationToSectorCheck_Record extends AITicketCheck_Record
{
	public import function Sectors( out outList : array< weak< AISectorType_Record > > );
	public import function GetSectorsCount() : Int32;
	public import function GetSectorsItem( index : Int32 ) : weak< AISectorType_Record >;
	public import function GetSectorsItemHandle( index : Int32 ) : AISectorType_Record;
	public import function SectorsContains( item : weak< AISectorType_Record > ) : Bool;
}

importonly class AISquadDistanceRelationToTargetCheck_Record extends AITicketCheck_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function RingRadius() : Float;
}

importonly class AISquadFilterByAICondition_Record extends AITicketFilter_Record
{
	public import function Condition() : weak< AIActionCondition_Record >;
	public import function ConditionHandle() : AIActionCondition_Record;
}

importonly class AISquadFilterOwnTargetSpotted_Record extends AITicketFilter_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
}

importonly class AISquadFurthestToSectorCheck_Record extends AISquadDistanceRelationToSectorCheck_Record
{
}

importonly class AISquadFurthestToTargetCheck_Record extends AISquadDistanceRelationToTargetCheck_Record
{
}

importonly class AISquadInSectorFilter_Record extends AITicketFilter_Record
{
	public import function Sectors( out outList : array< weak< AISectorType_Record > > );
	public import function GetSectorsCount() : Int32;
	public import function GetSectorsItem( index : Int32 ) : weak< AISectorType_Record >;
	public import function GetSectorsItemHandle( index : Int32 ) : AISectorType_Record;
	public import function SectorsContains( item : weak< AISectorType_Record > ) : Bool;
}

importonly class AISquadItemCategoryPriorityFilter_Record extends AISquadItemPriorityFilter_Record
{
	public import function Categories( out outList : array< weak< ItemCategory_Record > > );
	public import function GetCategoriesCount() : Int32;
	public import function GetCategoriesItem( index : Int32 ) : weak< ItemCategory_Record >;
	public import function GetCategoriesItemHandle( index : Int32 ) : ItemCategory_Record;
	public import function CategoriesContains( item : weak< ItemCategory_Record > ) : Bool;
}

importonly class AISquadItemPriorityFilter_Record extends AITicketFilter_Record
{
	public import function RestoreOnFail() : Bool;
}

importonly class AISquadItemTypePriorityFilter_Record extends AISquadItemPriorityFilter_Record
{
	public import function Types( out outList : array< weak< ItemType_Record > > );
	public import function GetTypesCount() : Int32;
	public import function GetTypesItem( index : Int32 ) : weak< ItemType_Record >;
	public import function GetTypesItemHandle( index : Int32 ) : ItemType_Record;
	public import function TypesContains( item : weak< ItemType_Record > ) : Bool;
}

importonly class AISquadJustSelfFilter_Record extends AITicketFilter_Record
{
}

importonly class AISquadMembersAmountCheck_Record extends AITicketCheck_Record
{
	public import function MaxAmount() : Int32;
	public import function MinAmount() : Int32;
	public import function CountSelf() : Bool;
}

importonly class AISquadORCondition_Record extends AITicketCheck_Record
{
	public import function OR( out outList : array< weak< AITicketCheck_Record > > );
	public import function GetORCount() : Int32;
	public import function GetORItem( index : Int32 ) : weak< AITicketCheck_Record >;
	public import function GetORItemHandle( index : Int32 ) : AITicketCheck_Record;
	public import function ORContains( item : weak< AITicketCheck_Record > ) : Bool;
}

importonly class AISquadParams_Record extends TweakDBRecord
{
	public import function AllTickets( out outList : array< weak< AITicket_Record > > );
	public import function GetAllTicketsCount() : Int32;
	public import function GetAllTicketsItem( index : Int32 ) : weak< AITicket_Record >;
	public import function GetAllTicketsItemHandle( index : Int32 ) : AITicket_Record;
	public import function AllTicketsContains( item : weak< AITicket_Record > ) : Bool;
	public import function OverridenTickets( out outList : array< weak< AITicket_Record > > );
	public import function GetOverridenTicketsCount() : Int32;
	public import function GetOverridenTicketsItem( index : Int32 ) : weak< AITicket_Record >;
	public import function GetOverridenTicketsItemHandle( index : Int32 ) : AITicket_Record;
	public import function OverridenTicketsContains( item : weak< AITicket_Record > ) : Bool;
	public import function ProhibitedTickets( out outList : array< weak< AITicketType_Record > > );
	public import function GetProhibitedTicketsCount() : Int32;
	public import function GetProhibitedTicketsItem( index : Int32 ) : weak< AITicketType_Record >;
	public import function GetProhibitedTicketsItemHandle( index : Int32 ) : AITicketType_Record;
	public import function ProhibitedTicketsContains( item : weak< AITicketType_Record > ) : Bool;
}

importonly class AISquadSpatialForOwnTarget_Record extends AITicketFilter_Record
{
	public import function Spatial() : weak< AISpatialCond_Record >;
	public import function SpatialHandle() : AISpatialCond_Record;
}

importonly class AISquadType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAISquadType;
}

importonly class AIStatPoolCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function StatPool() : weak< StatPool_Record >;
	public import function StatPoolHandle() : StatPool_Record;
	public import function Percentage() : Vector2;
	public import function IsIncreasing() : Int32;
}

importonly class AIStateCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function InStates() : array< CName >;
	public import function GetInStatesCount() : Int32;
	public import function GetInStatesItem( index : Int32 ) : CName;
	public import function InStatesContains( item : CName ) : Bool;
	public import function CheckAllTypes() : Bool;
}

importonly class AIStatusEffectCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function StatusEffectType() : weak< StatusEffectType_Record >;
	public import function StatusEffectTypeHandle() : StatusEffectType_Record;
	public import function GameplayTag() : CName;
}

importonly class AISubAction_Record extends TweakDBRecord
{
}

importonly class AISubActionActivateLightPreset_Record extends AISubAction_Record
{
	public import function LightPreset() : weak< LightPreset_Record >;
	public import function LightPresetHandle() : LightPreset_Record;
	public import function Delay() : Float;
}

importonly class AISubActionActivateStrongArmsFX_Record extends AISubAction_Record
{
	public import function Delay() : Float;
}

importonly class AISubActionAddFact_Record extends AISubAction_Record
{
	public import function Name() : CName;
	public import function Delay() : Float;
	public import function ResetValue() : Bool;
}

importonly class AISubActionApplyTimeDilation_Record extends AISubAction_Record
{
	public import function Condition() : weak< AIActionCondition_Record >;
	public import function ConditionHandle() : AIActionCondition_Record;
	public import function EaseOut() : CName;
	public import function EaseIn() : CName;
	public import function Reason() : CName;
	public import function Duration() : Float;
	public import function Multiplier() : Float;
	public import function OverrideMultiplerWhenPlayerInTimeDilation() : Float;
	public import function UseRealTime() : Bool;
}

importonly class AISubActionAttackWithWeapon_Record extends AISubAction_Record
{
	public import function Attack() : weak< Attack_Record >;
	public import function AttackHandle() : Attack_Record;
	public import function WeaponSlots( out outList : array< weak< AttachmentSlot_Record > > );
	public import function GetWeaponSlotsCount() : Int32;
	public import function GetWeaponSlotsItem( index : Int32 ) : weak< AttachmentSlot_Record >;
	public import function GetWeaponSlotsItemHandle( index : Int32 ) : AttachmentSlot_Record;
	public import function WeaponSlotsContains( item : weak< AttachmentSlot_Record > ) : Bool;
	public import function AttackName() : CName;
	public import function ColliderBoxSize() : Vector3;
	public import function ConeDirection() : Vector3;
	public import function PositionOffset() : Vector3;
	public import function AttackDuration() : Float;
	public import function AxisUpperMargin() : Float;
	public import function AxisLowerMargin() : Float;
	public import function AttackRange() : Float;
	public import function AttackTime() : Float;
	public import function ConeHalfAngle() : Float;
	public import function AttackWidth() : Float;
	public import function AttackInitRange() : Float;
	public import function StopContinuousAttackOnDurationEnd() : Bool;
}

importonly class AISubActionBlockData_Record extends AISubAction_Record
{
}

importonly class AISubActionCallReinforcements_Record extends AISubAction_Record
{
	public import function Duration() : Float;
	public import function Delay() : Float;
}

importonly class AISubActionCallSquadSearchBackUp_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Delay() : Float;
	public import function NumberOfTargets() : Float;
	public import function UseCommsCallLogic() : Bool;
	public import function Invert() : Bool;
}

importonly class AISubActionChangeAttitude_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Attitude() : CName;
	public import function Delay() : Float;
}

importonly class AISubActionChangeCoverSelectionPreset_Record extends AISubAction_Record
{
	public import function GatheringObjectCenter() : weak< AIActionTarget_Record >;
	public import function GatheringObjectCenterHandle() : AIActionTarget_Record;
	public import function InitialPreset() : CName;
	public import function Preset() : CName;
	public import function ChangeThreshold() : Float;
	public import function CoverDisablingDuration() : Float;
	public import function FallbackToLastSelectedPreset() : Bool;
}

importonly class AISubActionCharacterRecordEquip_Record extends AISubAction_Record
{
	public import function AnimationTime() : Float;
}

importonly class AISubActionCharacterRecordUnequip_Record extends AISubAction_Record
{
	public import function AnimationTime() : Float;
	public import function DropItem() : Bool;
}

importonly class AISubActionChimeraMetalstorm_Record extends AISubActionShootWithWeapon_Record
{
}

importonly class AISubActionCompleteCommand_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Commands() : array< CName >;
	public import function GetCommandsCount() : Int32;
	public import function GetCommandsItem( index : Int32 ) : CName;
	public import function CommandsContains( item : CName ) : Bool;
	public import function Delay() : Float;
	public import function CheckOneTimeExecutionFlag() : Bool;
}

importonly class AISubActionConditionalFailure_Record extends AISubAction_Record
{
	public import function Condition( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetConditionCount() : Int32;
	public import function GetConditionItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetConditionItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function ConditionContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function Cooldowns( out outList : array< weak< AIActionCooldown_Record > > );
	public import function GetCooldownsCount() : Int32;
	public import function GetCooldownsItem( index : Int32 ) : weak< AIActionCooldown_Record >;
	public import function GetCooldownsItemHandle( index : Int32 ) : AIActionCooldown_Record;
	public import function CooldownsContains( item : weak< AIActionCooldown_Record > ) : Bool;
	public import function Delay() : Float;
}

importonly class AISubActionCover_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function InsideCoverReselectionCooldown() : weak< AIActionCooldown_Record >;
	public import function InsideCoverReselectionCooldownHandle() : AIActionCooldown_Record;
	public import function ExposureMethodPriority( out outList : array< weak< AIExposureMethodType_Record > > );
	public import function GetExposureMethodPriorityCount() : Int32;
	public import function GetExposureMethodPriorityItem( index : Int32 ) : weak< AIExposureMethodType_Record >;
	public import function GetExposureMethodPriorityItemHandle( index : Int32 ) : AIExposureMethodType_Record;
	public import function ExposureMethodPriorityContains( item : weak< AIExposureMethodType_Record > ) : Bool;
	public import function CoverExposureMethods() : array< CName >;
	public import function GetCoverExposureMethodsCount() : Int32;
	public import function GetCoverExposureMethodsItem( index : Int32 ) : CName;
	public import function CoverExposureMethodsContains( item : CName ) : Bool;
	public import function CommandCoverConditions( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetCommandCoverConditionsCount() : Int32;
	public import function GetCommandCoverConditionsItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetCommandCoverConditionsItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function CommandCoverConditionsContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function PrioritizeBlindFireAfterHit() : Float;
	public import function SetDesiredCover() : Int32;
	public import function DelayExposedInCoverReset() : Float;
	public import function ClearLOSDistanceTolerance() : Float;
	public import function ExposedInCover() : Int32;
	public import function UseGrenadeThrowMethods() : Bool;
	public import function SetCurrentCover() : Bool;
	public import function SetCoverExposureAnim() : Bool;
	public import function SetInitialCoverData() : Bool;
	public import function UseLastAvailableExposureMethodsIfNoneAvailable() : Bool;
}

importonly class AISubActionCreateGameEffect_Record extends AISubAction_Record
{
	public import function PositionObj() : weak< AIActionTarget_Record >;
	public import function PositionObjHandle() : AIActionTarget_Record;
	public import function TargetPositionObj() : weak< AIActionTarget_Record >;
	public import function TargetPositionObjHandle() : AIActionTarget_Record;
	public import function RotationObj() : weak< AIActionTarget_Record >;
	public import function RotationObjHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function EffectTag() : CName;
	public import function EffectName() : CName;
	public import function ColliderBoxSize() : Vector3;
	public import function Range() : Float;
	public import function Duration() : Float;
	public import function Delay() : Float;
}

importonly class AISubActionCustomEffectors_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Effectors( out outList : array< weak< Effector_Record > > );
	public import function GetEffectorsCount() : Int32;
	public import function GetEffectorsItem( index : Int32 ) : weak< Effector_Record >;
	public import function GetEffectorsItemHandle( index : Int32 ) : Effector_Record;
	public import function EffectorsContains( item : weak< Effector_Record > ) : Bool;
	public import function Delay() : Float;
	public import function Remove() : Bool;
	public import function Apply() : Bool;
}

importonly class AISubActionDisableAimAssist_Record extends AISubAction_Record
{
	public import function Reason() : CName;
	public import function Delay() : Float;
	public import function Duration() : Float;
}

importonly class AISubActionDisableCollider_Record extends AISubAction_Record
{
	public import function Delay() : Float;
	public import function Disable() : Bool;
	public import function EnableOnDeactivate() : Bool;
}

importonly class AISubActionDroneModifyAltitude_Record extends AISubAction_Record
{
	public import function Delay() : Float;
	public import function AltitudeOffset() : Float;
}

importonly class AISubActionEquipOnBody_Record extends AISubActionCharacterRecordEquip_Record
{
}

importonly class AISubActionEquipOnSlot_Record extends AISubActionCharacterRecordEquip_Record
{
	public import function UseItemSpawnDelayFromWeapon() : Bool;
	public import function CacheEquippedItem() : Bool;
}

importonly class AISubActionFail_Record extends AISubAction_Record
{
}

importonly class AISubActionFailIfFriendlyFire_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function CheckOnlyFirstFrame() : Bool;
}

importonly class AISubActionFastExitWorkspot_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function DestinationObj() : weak< AIActionTarget_Record >;
	public import function DestinationObjHandle() : AIActionTarget_Record;
	public import function Delay() : Float;
	public import function PlaySlowExitIfFailed() : Bool;
	public import function StayInWorkspotIfFailed() : Bool;
}

importonly class AISubActionForceDeath_Record extends AISubAction_Record
{
	public import function Delay() : Float;
	public import function HitIntensity() : Int32;
	public import function HitBodyPart() : Int32;
	public import function HitSource() : Int32;
	public import function HitDirection() : Int32;
}

importonly class AISubActionForceEquip_Record extends AISubAction_Record
{
	public import function ItemObject() : weak< AIActionTarget_Record >;
	public import function ItemObjectHandle() : AIActionTarget_Record;
	public import function ItemID() : weak< Item_Record >;
	public import function ItemIDHandle() : Item_Record;
	public import function AttachmentSlot() : weak< AttachmentSlot_Record >;
	public import function AttachmentSlotHandle() : AttachmentSlot_Record;
	public import function ItemCategory() : weak< ItemCategory_Record >;
	public import function ItemCategoryHandle() : ItemCategory_Record;
	public import function ItemType() : weak< ItemType_Record >;
	public import function ItemTypeHandle() : ItemType_Record;
	public import function ItemTag() : CName;
	public import function Delay() : Float;
	public import function AnimationTime() : Float;
	public import function EquipDespiteInterruption() : Bool;
}

importonly class AISubActionForceHitReaction_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Delay() : Float;
	public import function HitType() : Int32;
	public import function HitIntensity() : Int32;
	public import function HitDirection() : Int32;
	public import function HitBodyPart() : Int32;
	public import function Stance() : Int32;
	public import function AnimVariation() : Int32;
	public import function HitSource() : Int32;
}

importonly class AISubActionForceUnequip_Record extends AISubAction_Record
{
	public import function AttachmentSlot() : weak< AttachmentSlot_Record >;
	public import function AttachmentSlotHandle() : AttachmentSlot_Record;
	public import function Delay() : Float;
	public import function AnimationTime() : Float;
	public import function UnequipDespiteInterruption() : Bool;
	public import function DropItem() : Bool;
	public import function GenerateLootAfterDrop() : Bool;
}

importonly class AISubActionGameplayLogicPackage_Record extends AISubAction_Record
{
	public import function Packages( out outList : array< weak< GameplayLogicPackage_Record > > );
	public import function GetPackagesCount() : Int32;
	public import function GetPackagesItem( index : Int32 ) : weak< GameplayLogicPackage_Record >;
	public import function GetPackagesItemHandle( index : Int32 ) : GameplayLogicPackage_Record;
	public import function PackagesContains( item : weak< GameplayLogicPackage_Record > ) : Bool;
}

importonly class AISubActionGeneratePointOfInterestTarget_Record extends AISubAction_Record
{
	public import function ClosestThreatDurationRange() : Vector2;
	public import function SquadMateDurationRange() : Vector2;
	public import function RandomPointDurationRange() : Vector2;
	public import function FriendlyTargetDurationRange() : Vector2;
	public import function RandomPointZRotationAngleRange() : Vector2;
	public import function RandomPointYRotationAngleRange() : Vector2;
	public import function SquadMateWatchingMaxAngle() : Float;
	public import function ChoosingRandomPointChanceWeight() : Float;
	public import function ChoosingFriendlyTargetChanceWeight() : Float;
	public import function ChoosingClosestThreatChanceWeight() : Float;
	public import function ChoosingSquadMateChanceWeight() : Float;
	public import function FriendlyTargetWatchingMaxAngle() : Float;
	public import function ClosestThreatWatchingMaxAngle() : Float;
}

importonly class AISubActionHitData_Record extends AISubAction_Record
{
	public import function DirectionObj() : weak< AIActionTarget_Record >;
	public import function DirectionObjHandle() : AIActionTarget_Record;
	public import function OverrideHitDirection() : Bool;
}

importonly class AISubActionInAir_Record extends AISubAction_Record
{
	public import function Delay() : Float;
}

importonly class AISubActionInitialReaction_Record extends AISubAction_Record
{
	public import function DirectionObj() : weak< AIActionTarget_Record >;
	public import function DirectionObjHandle() : AIActionTarget_Record;
}

importonly class AISubActionLeaveCover_Record extends AISubAction_Record
{
	public import function Delay() : Float;
	public import function CheckExposure() : Int32;
}

importonly class AISubActionMeleeAttackAttemptEvent_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function IsWindUp() : Bool;
}

importonly class AISubActionMeleeAttackManager_Record extends AISubAction_Record
{
	public import function Name() : CName;
	public import function FxDelay() : Float;
	public import function TrailDuration() : Float;
	public import function TrailDelay() : Float;
	public import function WarningDelay() : Float;
	public import function SpawnTrail() : Bool;
	public import function SpawnWeaponFX() : Bool;
	public import function SendFriendlyFireWarning() : Bool;
}

importonly class AISubActionMissileRainCircular_Record extends AISubActionShootWithWeapon_Record
{
	public import function MinRadius() : Float;
	public import function MissilesPerLaunch() : Int32;
	public import function MaxRadius() : Float;
}

importonly class AISubActionMissileRainGrid_Record extends AISubActionShootWithWeapon_Record
{
	public import function MissileOffsets() : array< Vector3 >;
	public import function GetMissileOffsetsCount() : Int32;
	public import function GetMissileOffsetsItem( index : Int32 ) : Vector3;
	public import function MissileOffsetsContains( item : Vector3 ) : Bool;
}

importonly class AISubActionModifyStatPool_Record extends AISubAction_Record
{
	public import function StatPool() : weak< StatPool_Record >;
	public import function StatPoolHandle() : StatPool_Record;
	public import function Delay() : Float;
	public import function Amount() : Float;
	public import function Perc() : Bool;
}

importonly class AISubActionMountVehicle_Record extends AISubAction_Record
{
	public import function Vehicle() : weak< AIActionTarget_Record >;
	public import function VehicleHandle() : AIActionTarget_Record;
	public import function Slot() : weak< VehicleSeat_Record >;
	public import function SlotHandle() : VehicleSeat_Record;
	public import function MountInstantly() : Bool;
	public import function IgnoreFlatTires() : Bool;
}

importonly class AISubActionPlaySound_Record extends AISubAction_Record
{
	public import function AttachmentSlot() : weak< AttachmentSlot_Record >;
	public import function AttachmentSlotHandle() : AttachmentSlot_Record;
	public import function Name() : CName;
	public import function Delay() : Float;
}

importonly class AISubActionPlayVoiceOver_Record extends AISubAction_Record
{
	public import function Condition() : weak< AIActionCondition_Record >;
	public import function ConditionHandle() : AIActionCondition_Record;
	public import function Cooldown() : weak< AIActionCooldown_Record >;
	public import function CooldownHandle() : AIActionCooldown_Record;
	public import function Name() : CName;
	public import function Delay() : Float;
	public import function SendEventToSquadmates() : Bool;
	public import function SetSelfAsAnsweringEntity() : Bool;
	public import function Repeat() : Bool;
}

importonly class AISubActionQueueAIEvent_Record extends AISubAction_Record
{
	public import function Name() : CName;
	public import function Delay() : Float;
}

importonly class AISubActionQueueCommunicationEvent_Record extends AISubAction_Record
{
	public import function TargetListener() : weak< AIActionTarget_Record >;
	public import function TargetListenerHandle() : AIActionTarget_Record;
	public import function Name() : CName;
	public import function Delay() : Float;
}

importonly class AISubActionQuickHack_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function ActionResult() : weak< ObjectAction_Record >;
	public import function ActionResultHandle() : ObjectAction_Record;
	public import function EstablishContactOnly() : Bool;
}

importonly class AISubActionRandomize_Record extends AISubAction_Record
{
	public import function AnimVariationRandomize() : array< Int32 >;
	public import function GetAnimVariationRandomizeCount() : Int32;
	public import function GetAnimVariationRandomizeItem( index : Int32 ) : Int32;
	public import function AnimVariationRandomizeContains( item : Int32 ) : Bool;
}

importonly class AISubActionRegisterActionName_Record extends AISubAction_Record
{
	public import function ActionName() : CName;
}

importonly class AISubActionReloadWeapon_Record extends AISubAction_Record
{
	public import function WeaponSlot() : weak< AttachmentSlot_Record >;
	public import function WeaponSlotHandle() : AttachmentSlot_Record;
	public import function Duration() : Float;
}

importonly class AISubActionScaleDurationWithDistance_Record extends AISubAction_Record
{
	public import function Source() : weak< AIActionTarget_Record >;
	public import function SourceHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function DistanceRange() : Vector2;
	public import function ScaleDistanceToTime() : Vector2;
}

importonly class AISubActionSecuritySystemNotification_Record extends AISubAction_Record
{
	public import function Threat() : weak< AIActionTarget_Record >;
	public import function ThreatHandle() : AIActionTarget_Record;
	public import function NotificationType() : weak< AIActionSecurityNotificationType_Record >;
	public import function NotificationTypeHandle() : AIActionSecurityNotificationType_Record;
}

importonly class AISubActionSendSignal_Record extends AISubAction_Record
{
	public import function Name() : CName;
	public import function Duration() : Float;
	public import function Delay() : Float;
}

importonly class AISubActionSetEquipPrimaryWeapons_Record extends AISubActionCharacterRecordEquip_Record
{
}

importonly class AISubActionSetEquipSecondaryWeapons_Record extends AISubActionCharacterRecordEquip_Record
{
}

importonly class AISubActionSetInfluenceMap_Record extends AISubAction_Record
{
	public import function PositionObj() : weak< AIActionTarget_Record >;
	public import function PositionObjHandle() : AIActionTarget_Record;
	public import function Lerp() : Vector2;
	public import function Delay() : Float;
	public import function Radius() : Float;
	public import function Threat() : Bool;
}

importonly class AISubActionSetInt_Record extends AISubAction_Record
{
	public import function Name() : CName;
	public import function Delay() : Float;
	public import function Value() : Int32;
}

importonly class AISubActionSetItemAsTarget_Record extends AISubActionSetTargetByTag_Record
{
	public import function ItemCategory() : weak< ItemCategory_Record >;
	public import function ItemCategoryHandle() : ItemCategory_Record;
	public import function ItemType() : weak< ItemType_Record >;
	public import function ItemTypeHandle() : ItemType_Record;
}

importonly class AISubActionSetStimSource_Record extends AISubAction_Record
{
	public import function StimTarget() : weak< AIActionTarget_Record >;
	public import function StimTargetHandle() : AIActionTarget_Record;
	public import function Delay() : Float;
	public import function UseInvestigateData() : Bool;
	public import function RevertStimSourceDirection() : Bool;
}

importonly class AISubActionSetTargetByTag_Record extends AISubAction_Record
{
	public import function RangeObj() : weak< AIActionTarget_Record >;
	public import function RangeObjHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function LineOfSightTarget() : weak< AIActionTarget_Record >;
	public import function LineOfSightTargetHandle() : AIActionTarget_Record;
	public import function AllowedOffMeshTags() : array< CName >;
	public import function GetAllowedOffMeshTagsCount() : Int32;
	public import function GetAllowedOffMeshTagsItem( index : Int32 ) : CName;
	public import function AllowedOffMeshTagsContains( item : CName ) : Bool;
	public import function SelectionMethod() : CName;
	public import function Tag() : CName;
	public import function RangeFromOwner() : Vector2;
	public import function RangeFromObj() : Vector2;
	public import function AvoidSelectingSameTargetMethod() : Int32;
	public import function Delay() : Float;
	public import function BlockLoSByNonPenetrableObj() : Bool;
}

importonly class AISubActionSetTopThreatPersistance_Record extends AISubAction_Record
{
	public import function Source() : weak< AIThreatPersistenceSource_Record >;
	public import function SourceHandle() : AIThreatPersistenceSource_Record;
}

importonly class AISubActionSetUnequipPrimaryWeapons_Record extends AISubActionCharacterRecordUnequip_Record
{
}

importonly class AISubActionSetUnequipSecondaryWeapons_Record extends AISubActionCharacterRecordUnequip_Record
{
}

importonly class AISubActionSetWaypointByTag_Record extends AISubActionSetTargetByTag_Record
{
}

importonly class AISubActionSetWorldPosition_Record extends AISubAction_Record
{
	public import function CustomPositionTarget() : weak< AIActionTarget_Record >;
	public import function CustomPositionTargetHandle() : AIActionTarget_Record;
	public import function ReferenceTarget() : weak< AIActionTarget_Record >;
	public import function ReferenceTargetHandle() : AIActionTarget_Record;
	public import function MinOffsetFromTarget() : Vector3;
	public import function MaxOffsetFromTarget() : Vector3;
	public import function RandomizePoint() : Bool;
	public import function UseLocalSpace() : Bool;
	public import function CheckForNavmesh() : Bool;
}

importonly class AISubActionShootFromCar_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Instigator() : weak< AIActionTarget_Record >;
	public import function InstigatorHandle() : AIActionTarget_Record;
	public import function Delay() : Float;
}

importonly class AISubActionShootToPoint_Record extends AISubActionShootWithWeapon_Record
{
	public import function RotationObj() : weak< AIActionTarget_Record >;
	public import function RotationObjHandle() : AIActionTarget_Record;
	public import function PositionObj() : weak< AIActionTarget_Record >;
	public import function PositionObjHandle() : AIActionTarget_Record;
	public import function TargetPositionObj() : weak< AIActionTarget_Record >;
	public import function TargetPositionObjHandle() : AIActionTarget_Record;
	public import function PointPosition() : array< Vector3 >;
	public import function GetPointPositionCount() : Int32;
	public import function GetPointPositionItem( index : Int32 ) : Vector3;
	public import function PointPositionContains( item : Vector3 ) : Bool;
	public import function WaypointTag() : array< CName >;
	public import function GetWaypointTagCount() : Int32;
	public import function GetWaypointTagItem( index : Int32 ) : CName;
	public import function WaypointTagContains( item : CName ) : Bool;
}

importonly class AISubActionShootWithWeapon_Record extends AISubAction_Record
{
	public import function Instigator() : weak< AIActionTarget_Record >;
	public import function InstigatorHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function RangedAttack() : weak< RangedAttack_Record >;
	public import function RangedAttackHandle() : RangedAttack_Record;
	public import function TriggerMode() : weak< TriggerMode_Record >;
	public import function TriggerModeHandle() : TriggerMode_Record;
	public import function ShootingPatternPackages( out outList : array< weak< AIPatternsPackage_Record > > );
	public import function GetShootingPatternPackagesCount() : Int32;
	public import function GetShootingPatternPackagesItem( index : Int32 ) : weak< AIPatternsPackage_Record >;
	public import function GetShootingPatternPackagesItemHandle( index : Int32 ) : AIPatternsPackage_Record;
	public import function ShootingPatternPackagesContains( item : weak< AIPatternsPackage_Record > ) : Bool;
	public import function PauseCondition( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetPauseConditionCount() : Int32;
	public import function GetPauseConditionItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetPauseConditionItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function PauseConditionContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function WeaponSlots( out outList : array< weak< AttachmentSlot_Record > > );
	public import function GetWeaponSlotsCount() : Int32;
	public import function GetWeaponSlotsItem( index : Int32 ) : weak< AttachmentSlot_Record >;
	public import function GetWeaponSlotsItemHandle( index : Int32 ) : AttachmentSlot_Record;
	public import function WeaponSlotsContains( item : weak< AttachmentSlot_Record > ) : Bool;
	public import function DualWieldShootingStyle() : CName;
	public import function WeaponCustomEvent() : CName;
	public import function TargetOffset() : Vector3;
	public import function Delay() : Float;
	public import function PauseConditionCheckInterval() : Float;
	public import function TbhCoefficient() : Float;
	public import function AimingDelay() : Float;
	public import function PredictionTime() : Float;
	public import function NumberOfShots() : Int32;
	public import function MaxNumberOfShots() : Int32;
}

importonly class AISubActionSpawnFX_Record extends AISubAction_Record
{
	public import function AttachmentSlot() : weak< AttachmentSlot_Record >;
	public import function AttachmentSlotHandle() : AttachmentSlot_Record;
	public import function Name() : CName;
	public import function Delay() : Float;
}

importonly class AISubActionSquadSync_Record extends AISubAction_Record
{
	public import function SquadType() : weak< AISquadType_Record >;
	public import function SquadTypeHandle() : AISquadType_Record;
	public import function Pull() : Bool;
}

importonly class AISubActionStartCooldown_Record extends AISubAction_Record
{
	public import function Cooldowns( out outList : array< weak< AIActionCooldown_Record > > );
	public import function GetCooldownsCount() : Int32;
	public import function GetCooldownsItem( index : Int32 ) : weak< AIActionCooldown_Record >;
	public import function GetCooldownsItemHandle( index : Int32 ) : AIActionCooldown_Record;
	public import function CooldownsContains( item : weak< AIActionCooldown_Record > ) : Bool;
	public import function Delay() : Float;
	public import function MinActionDuration() : Float;
}

importonly class AISubActionStatusEffect_Record extends AISubAction_Record
{
	public import function Condition() : weak< AIActionCondition_Record >;
	public import function ConditionHandle() : AIActionCondition_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function StatusEffects( out outList : array< weak< StatusEffect_Record > > );
	public import function GetStatusEffectsCount() : Int32;
	public import function GetStatusEffectsItem( index : Int32 ) : weak< StatusEffect_Record >;
	public import function GetStatusEffectsItemHandle( index : Int32 ) : StatusEffect_Record;
	public import function StatusEffectsContains( item : weak< StatusEffect_Record > ) : Bool;
	public import function Delay() : Float;
	public import function Apply() : Bool;
	public import function Remove() : Bool;
}

importonly class AISubActionThrowItem_Record extends AISubAction_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function AttachmentSlot() : weak< AttachmentSlot_Record >;
	public import function AttachmentSlotHandle() : AttachmentSlot_Record;
	public import function ThrowType() : CName;
	public import function PositionPredictionTime() : Float;
	public import function Delay() : Float;
	public import function ThrowAngle() : Float;
	public import function TrajectoryGravity() : Float;
	public import function DropItemOnInterruption() : Bool;
	public import function CheckThrowQuery() : Bool;
}

importonly class AISubActionTriggerItemActivation_Record extends AISubAction_Record
{
	public import function AttachmentSlot() : weak< AttachmentSlot_Record >;
	public import function AttachmentSlotHandle() : AttachmentSlot_Record;
	public import function Instigator() : weak< AIActionTarget_Record >;
	public import function InstigatorHandle() : AIActionTarget_Record;
	public import function Delay() : Float;
}

importonly class AISubActionTriggerStim_Record extends AISubAction_Record
{
	public import function StimType() : weak< StimType_Record >;
	public import function StimTypeHandle() : StimType_Record;
	public import function StimSource() : weak< AIActionTarget_Record >;
	public import function StimSourceHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Delay() : Float;
	public import function Radius() : Float;
	public import function Direct() : Bool;
	public import function PurelyDirect() : Bool;
}

importonly class AISubActionUnequipOnSlot_Record extends AISubActionCharacterRecordUnequip_Record
{
	public import function UseItemSpawnDelayFromWeapon() : Bool;
}

importonly class AISubActionUpdateFriendlyFireParams_Record extends AISubAction_Record
{
	public import function UpdateOnDeactivate() : Bool;
}

importonly class AISubActionUseSensePreset_Record extends AISubAction_Record
{
	public import function SensePreset() : weak< SensePreset_Record >;
	public import function SensePresetHandle() : SensePreset_Record;
	public import function Delay() : Float;
}

importonly class AISubActionWorkspot_Record extends AISubAction_Record
{
	public import function WorkspotObject() : weak< AIActionTarget_Record >;
	public import function WorkspotObjectHandle() : AIActionTarget_Record;
}

importonly class AITacticTicket_Record extends AITicket_Record
{
	public import function Sectors( out outList : array< weak< AISectorType_Record > > );
	public import function GetSectorsCount() : Int32;
	public import function GetSectorsItem( index : Int32 ) : weak< AISectorType_Record >;
	public import function GetSectorsItemHandle( index : Int32 ) : AISectorType_Record;
	public import function SectorsContains( item : weak< AISectorType_Record > ) : Bool;
	public import function TacticTimeout() : Float;
	public import function OffensiveTactic() : Bool;
}

importonly class AITacticType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAITacticType;
}

importonly class AITargetCond_Record extends AIActionSubCondition_Record
{
	public import function IsCombatTargetVisibleFrom() : weak< AIAdditionalTraceType_Record >;
	public import function IsCombatTargetVisibleFromHandle() : AIAdditionalTraceType_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function MinAccuracyValue() : Float;
	public import function MinDetectionValue() : Float;
	public import function IsVisible() : Int32;
	public import function InvalidExpectation() : Int32;
	public import function MinAccuracySharedValue() : Float;
	public import function IsAlive() : Int32;
	public import function MaxVisibilityToTargetDistance() : Float;
	public import function IsActive() : Int32;
	public import function IsMoving() : Int32;
	public import function Attitude() : Int32;
}

importonly class AITargetInPreventionFreeArea_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
}

importonly class AITargetInUnmountingRangeCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
}

importonly class AITargetStandingOnTopOfMovingVehicleCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
}

importonly class AIThreatPersistenceSource_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function EnumValue() : Int32;
	public import function Type() : gamedataAIThreatPersistenceSource;
}

importonly class AIThrowCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function WeaponSlot() : weak< AttachmentSlot_Record >;
	public import function WeaponSlotHandle() : AttachmentSlot_Record;
	public import function PredictionTime() : Float;
	public import function ThrowAngle() : Float;
	public import function ClearLOSDistanceTolerance() : Float;
}

importonly class AITicket_Record extends TweakDBRecord
{
	public import function TicketType() : weak< AITicketType_Record >;
	public import function TicketTypeHandle() : AITicketType_Record;
	public import function Difficulty() : weak< AIDifficulty_Record >;
	public import function DifficultyHandle() : AIDifficulty_Record;
	public import function DifficultyComparisonOp() : weak< AIComparison_Record >;
	public import function DifficultyComparisonOpHandle() : AIComparison_Record;
	public import function DeactivationCondition( out outList : array< weak< AITicketCondition_Record > > );
	public import function GetDeactivationConditionCount() : Int32;
	public import function GetDeactivationConditionItem( index : Int32 ) : weak< AITicketCondition_Record >;
	public import function GetDeactivationConditionItemHandle( index : Int32 ) : AITicketCondition_Record;
	public import function DeactivationConditionContains( item : weak< AITicketCondition_Record > ) : Bool;
	public import function ActivationCondition( out outList : array< weak< AITicketCondition_Record > > );
	public import function GetActivationConditionCount() : Int32;
	public import function GetActivationConditionItem( index : Int32 ) : weak< AITicketCondition_Record >;
	public import function GetActivationConditionItemHandle( index : Int32 ) : AITicketCondition_Record;
	public import function ActivationConditionContains( item : weak< AITicketCondition_Record > ) : Bool;
	public import function SyncWithTickets( out outList : array< weak< AITicketType_Record > > );
	public import function GetSyncWithTicketsCount() : Int32;
	public import function GetSyncWithTicketsItem( index : Int32 ) : weak< AITicketType_Record >;
	public import function GetSyncWithTicketsItemHandle( index : Int32 ) : AITicketType_Record;
	public import function SyncWithTicketsContains( item : weak< AITicketType_Record > ) : Bool;
	public import function Cooldowns( out outList : array< weak< AIActionCooldown_Record > > );
	public import function GetCooldownsCount() : Int32;
	public import function GetCooldownsItem( index : Int32 ) : weak< AIActionCooldown_Record >;
	public import function GetCooldownsItemHandle( index : Int32 ) : AIActionCooldown_Record;
	public import function CooldownsContains( item : weak< AIActionCooldown_Record > ) : Bool;
	public import function ConditionSuccessDuration() : Float;
	public import function MinTicketDesyncTime() : Float;
	public import function MaxTicketDesyncTime() : Float;
	public import function MaxNumberOfTickets() : Int32;
	public import function PercentageNumberOfTickets() : Float;
	public import function Timeout() : Float;
	public import function SyncTimeout() : Float;
	public import function MinNumberOfTickets() : Int32;
	public import function DeactivationConditionCheckInterval() : Float;
	public import function ScaleNumberOfTicketsFromWorkspots() : Bool;
	public import function RevokeOnTimeout() : Bool;
	public import function ReleaseAll() : Bool;
	public import function StartCooldownOnFailure() : Bool;
}

importonly class AITicketCheck_Record extends AITicketCondition_Record
{
	public import function OptionalFastExit() : Bool;
}

importonly class AITicketCondition_Record extends TweakDBRecord
{
	public import function Invert() : Bool;
}

importonly class AITicketFilter_Record extends AITicketCondition_Record
{
	public import function ResetMembers() : Bool;
	public import function ResetMembersIncludingUnwillings() : Bool;
	public import function SkipSelfOnce() : Bool;
}

importonly class AITicketType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAITicketType;
}

importonly class AITresspassingCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function CheckSafeArea() : Bool;
}

importonly class AIValidCoversCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function LimitToRings( out outList : array< weak< AIRingType_Record > > );
	public import function GetLimitToRingsCount() : Int32;
	public import function GetLimitToRingsItem( index : Int32 ) : weak< AIRingType_Record >;
	public import function GetLimitToRingsItemHandle( index : Int32 ) : AIRingType_Record;
	public import function LimitToRingsContains( item : weak< AIRingType_Record > ) : Bool;
	public import function CoversWithLOS() : Int32;
	public import function CheckCurrentlyActiveRing() : Bool;
}

importonly class AIVehicleCond_Record extends AIActionSubCondition_Record
{
	public import function Vehicle() : weak< AIActionTarget_Record >;
	public import function VehicleHandle() : AIActionTarget_Record;
	public import function HasTags() : array< CName >;
	public import function GetHasTagsCount() : Int32;
	public import function GetHasTagsItem( index : Int32 ) : CName;
	public import function HasTagsContains( item : CName ) : Bool;
	public import function FreeSlots( out outList : array< weak< VehicleSeat_Record > > );
	public import function GetFreeSlotsCount() : Int32;
	public import function GetFreeSlotsItem( index : Int32 ) : weak< VehicleSeat_Record >;
	public import function GetFreeSlotsItemHandle( index : Int32 ) : VehicleSeat_Record;
	public import function FreeSlotsContains( item : weak< VehicleSeat_Record > ) : Bool;
	public import function ActivePassangers() : Vector2;
	public import function CurrentSpeed() : Vector2;
	public import function DriverCheck() : Int32;
}

importonly class AIVehicleInsideInnerAreaOfAreaSpeedLimiter_Record extends AIActionSubCondition_Record
{
	public import function Vehicle() : weak< AIActionTarget_Record >;
	public import function VehicleHandle() : AIActionTarget_Record;
}

importonly class AIVelocitiesDotCond_Record extends AIActionSubCondition_Record
{
	public import function FirstTarget() : weak< AIActionTarget_Record >;
	public import function FirstTargetHandle() : AIActionTarget_Record;
	public import function SecondTarget() : weak< AIActionTarget_Record >;
	public import function SecondTargetHandle() : AIActionTarget_Record;
	public import function DotRange() : Vector2;
	public import function FirstTimePeriod() : Float;
	public import function SecondTimePeriod() : Float;
}

importonly class AIVelocityCond_Record extends AIActionSubCondition_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Range() : Vector2;
	public import function TimePeriod() : Float;
}

importonly class AIVelocityDotCond_Record extends AIActionSubCondition_Record
{
	public import function VelocityTarget() : weak< AIActionTarget_Record >;
	public import function VelocityTargetHandle() : AIActionTarget_Record;
	public import function PositionTarget() : weak< AIActionTarget_Record >;
	public import function PositionTargetHandle() : AIActionTarget_Record;
	public import function DotRange() : Vector2;
	public import function TimePeriod() : Float;
}

importonly class AIWeakSpotCond_Record extends AIActionSubCondition_Record
{
	public import function Weakspot() : weak< Weakspot_Record >;
	public import function WeakspotHandle() : Weakspot_Record;
	public import function IncludeDestroyed() : Bool;
}

importonly class AIWeaponLockedOnTargetCond_Record extends AIActionSubCondition_Record
{
	public import function WeaponSlot() : weak< AttachmentSlot_Record >;
	public import function WeaponSlotHandle() : AttachmentSlot_Record;
}

importonly class AIWorkspotCond_Record extends AIActionSubCondition_Record
{
	public import function WorkspotObj() : weak< AIActionTarget_Record >;
	public import function WorkspotObjHandle() : AIActionTarget_Record;
	public import function IsInWorkspot() : Int32;
}

importonly class AbsoluteZLimiterCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function ZLimit() : Float;
}

importonly class AccelerateTowardsParameters_Record extends TweakDBRecord
{
	public import function MaxSpeed() : Float;
	public import function MaxRotationSpeed() : Float;
	public import function DecelerateTowardsTargetPositionDistance() : Float;
	public import function DiffForMaxRotation() : Float;
	public import function AccelerationSpeed() : Float;
	public import function MinRotationSpeed() : Float;
	public import function Accuracy() : Float;
}

importonly class Accuracy_Record extends TweakDBRecord
{
	public import function AccuracyDropCooldown() : Float;
	public import function MinDistanceToRunCooldown() : Float;
}

importonly class Achievement_Record extends TweakDBRecord
{
	public import function SteamKey() : String;
	public import function GOGKey() : String;
	public import function LocalizedDescription() : String;
	public import function XB1Key() : String;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function DisplayName() : CName;
	public import function EnumName() : CName;
	public import function PS4Key() : Int32;
	public import function ThresholdValue() : Int32;
	public import function PlaythroughSpecific() : Bool;
	public import function Type() : gamedataAchievement;
}

importonly class ActionMap_Record extends TweakDBRecord
{
	public import function DefaultMap() : weak< AINodeMap_Record >;
	public import function DefaultMapHandle() : AINodeMap_Record;
	public import function Map( out outList : array< weak< ActionMapField_Record > > );
	public import function GetMapCount() : Int32;
	public import function GetMapItem( index : Int32 ) : weak< ActionMapField_Record >;
	public import function GetMapItemHandle( index : Int32 ) : ActionMapField_Record;
	public import function MapContains( item : weak< ActionMapField_Record > ) : Bool;
}

importonly class ActionMapField_Record extends TweakDBRecord
{
	public import function ItemType() : weak< ItemType_Record >;
	public import function ItemTypeHandle() : ItemType_Record;
	public import function Map() : weak< AINodeMap_Record >;
	public import function MapHandle() : AINodeMap_Record;
}

importonly class ActionPayment_Record extends ObjectAction_Record
{
}

importonly class ActionRestrictionGroup_Record extends TweakDBRecord
{
	public import function InactiveReason() : String;
	public import function AllowedActionNames() : array< String >;
	public import function GetAllowedActionNamesCount() : Int32;
	public import function GetAllowedActionNamesItem( index : Int32 ) : String;
	public import function AllowedActionNamesContains( item : String ) : Bool;
	public import function DisallowedActionNames() : array< String >;
	public import function GetDisallowedActionNamesCount() : Int32;
	public import function GetDisallowedActionNamesItem( index : Int32 ) : String;
	public import function DisallowedActionNamesContains( item : String ) : Bool;
}

importonly class ActionTargetInDistancePrereq_Record extends IPrereq_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function DistanceStat() : weak< Stat_Record >;
	public import function DistanceStatHandle() : Stat_Record;
	public import function Distance() : Float;
	public import function Invert() : Bool;
}

importonly class ActionTargetPrereq_Record extends IPrereq_Record
{
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function Invert() : Bool;
}

importonly class ActionWidgetDefinition_Record extends WidgetDefinition_Record
{
}

importonly class AddDevelopmentPointEffector_Record extends Effector_Record
{
	public import function PointsType() : String;
	public import function AmountOfPoints() : Int32;
}

importonly class AddHitFlagToAttackEffector_Record extends Effector_Record
{
	public import function HitFlag() : String;
}

importonly class AddItemsEffector_Record extends Effector_Record
{
	public import function ItemsToAdd( out outList : array< weak< InventoryItem_Record > > );
	public import function GetItemsToAddCount() : Int32;
	public import function GetItemsToAddItem( index : Int32 ) : weak< InventoryItem_Record >;
	public import function GetItemsToAddItemHandle( index : Int32 ) : InventoryItem_Record;
	public import function ItemsToAddContains( item : weak< InventoryItem_Record > ) : Bool;
}

importonly class AddStatusEffectToAttackEffector_Record extends Effector_Record
{
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function ApplicationChance( out outList : array< weak< StatModifier_Record > > );
	public import function GetApplicationChanceCount() : Int32;
	public import function GetApplicationChanceItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetApplicationChanceItemHandle( index : Int32 ) : StatModifier_Record;
	public import function ApplicationChanceContains( item : weak< StatModifier_Record > ) : Bool;
	public import function Stacks() : Float;
	public import function IsRandom() : Bool;
}

importonly class AddStatusEffectToAttackEffector_inline0_Record extends ConstantStatModifier_Record
{
}

importonly class Advertisement_Record extends TweakDBRecord
{
	public import function Definitions( out outList : array< weak< AdvertisementFormatDef_Record > > );
	public import function GetDefinitionsCount() : Int32;
	public import function GetDefinitionsItem( index : Int32 ) : weak< AdvertisementFormatDef_Record >;
	public import function GetDefinitionsItemHandle( index : Int32 ) : AdvertisementFormatDef_Record;
	public import function DefinitionsContains( item : weak< AdvertisementFormatDef_Record > ) : Bool;
	public import function LocalizationKey() : CName;
	public import function Resource() : ResRef;
}

importonly class AdvertisementFormatDef_Record extends TweakDBRecord
{
	public import function Format() : String;
	public import function LibraryName() : String;
	public import function LocalizationKeyOverride() : CName;
}

importonly class AdvertisementFormatsEnum_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
}

importonly class AdvertisementGroup_Record extends TweakDBRecord
{
	public import function IncludedGroups( out outList : array< weak< AdvertisementGroup_Record > > );
	public import function GetIncludedGroupsCount() : Int32;
	public import function GetIncludedGroupsItem( index : Int32 ) : weak< AdvertisementGroup_Record >;
	public import function GetIncludedGroupsItemHandle( index : Int32 ) : AdvertisementGroup_Record;
	public import function IncludedGroupsContains( item : weak< AdvertisementGroup_Record > ) : Bool;
	public import function Advertisements( out outList : array< weak< Advertisement_Record > > );
	public import function GetAdvertisementsCount() : Int32;
	public import function GetAdvertisementsItem( index : Int32 ) : weak< Advertisement_Record >;
	public import function GetAdvertisementsItemHandle( index : Int32 ) : Advertisement_Record;
	public import function AdvertisementsContains( item : weak< Advertisement_Record > ) : Bool;
	public import function FallbackAtlasResource() : ResRef;
	public import function LightTintColor() : Vector3;
	public import function AdvertTintColor() : Vector3;
}

importonly class Affiliation_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function AnimWrappers() : array< CName >;
	public import function GetAnimWrappersCount() : Int32;
	public import function GetAnimWrappersItem( index : Int32 ) : CName;
	public import function AnimWrappersContains( item : CName ) : Bool;
	public import function LocalizedName() : CName;
	public import function EnumName() : CName;
	public import function IconPath() : CName;
	public import function Type() : gamedataAffiliation;
}

importonly class AimAssistAimSnap_Record extends TweakDBRecord
{
	public import function Duration() : Float;
	public import function BptMaxDot() : Float;
	public import function BptMinInputMag() : Float;
	public import function CameraInputMagToBreak() : Float;
	public import function Precision() : Float;
	public import function BptMaxSwitches() : Float;
	public import function MaxDistance() : Float;
	public import function MinDistance() : Float;
	public import function MaxDuration() : Float;
	public import function CameraMouseInputMagToBreak() : Float;
	public import function TargetAngleDistanceFactor() : Float;
	public import function BptMinMouseInputMag() : Float;
	public import function BptMinResetInputMag() : Float;
	public import function BodyPartsTracking() : Bool;
	public import function EndOnCameraInputApplied() : Bool;
	public import function IsEnabled() : Bool;
	public import function EaseOut() : Bool;
	public import function AdjustYaw() : Bool;
	public import function BreakOnDistance() : Bool;
	public import function EvaluateTargets() : Bool;
	public import function EndOnAimingStopped() : Bool;
	public import function EndOnTimeExceeded() : Bool;
	public import function EaseIn() : Bool;
	public import function CancelWithRecoil() : Bool;
	public import function EndOnTargetReached() : Bool;
	public import function AdjustPitch() : Bool;
	public import function IgnoreInputType() : Bool;
	public import function AffectedByRecoil() : Bool;
	public import function CheckRange() : Bool;
	public import function TargetCycling() : Bool;
}

importonly class AimAssistBulletMagnetism_Record extends TweakDBRecord
{
	public import function TargetSearchAngleYaw() : Float;
	public import function TargetSearchAnglePitch() : Float;
	public import function TargetHighAngularVelocity() : Float;
	public import function MagPointOffset() : Float;
	public import function DeadReckoningSearchAnglePitch() : Float;
	public import function DeadReckoningSearchAngleYaw() : Float;
	public import function IsEnabled() : Bool;
}

importonly class AimAssistCommon_Record extends TweakDBRecord
{
	public import function TargetFilterPriority() : weak< SearchFilterMaskTypeCondition_Record >;
	public import function TargetFilterPriorityHandle() : SearchFilterMaskTypeCondition_Record;
	public import function AimAssistType() : weak< AimAssistType_Record >;
	public import function AimAssistTypeHandle() : AimAssistType_Record;
	public import function TargetFilter() : weak< SearchFilterMaskTypeCondition_Record >;
	public import function TargetFilterHandle() : SearchFilterMaskTypeCondition_Record;
	public import function SoftLockBrakeAngle() : EulerAngles;
	public import function FirstPassAngleRange() : EulerAngles;
	public import function WorldProximityThreshold() : Float;
	public import function AngleProximityBonus() : Float;
	public import function RotatingAwayFromPastTargetPenalty() : Float;
	public import function WorldDistUnitWeight() : Float;
	public import function TargetLostTimeOut() : Float;
	public import function SoftLockTargetLostTimeOut() : Float;
	public import function PastTargetWeight() : Float;
	public import function WorldProximityBonus() : Float;
	public import function AngleProximityThreshold() : Float;
	public import function WorldDistUnit() : Float;
	public import function AngleDistUnitWeight() : Float;
	public import function SoftLockTargetWeight() : Float;
	public import function AngleDistUnit() : Float;
	public import function TargetFilterPriorityBonus() : Float;
	public import function TargetAcquisitionDelayTime() : Float;
	public import function RecentInputTime() : Float;
	public import function ForceSoftLockMinimumWeight() : Bool;
	public import function IsEnabled() : Bool;
	public import function IsEnabledForMouse() : Bool;
	public import function PrimaryComponentsOnly() : Bool;
}

importonly class AimAssistConfigPreset_Record extends TweakDBRecord
{
	public import function MagnetismParams() : weak< AimAssistMagnetism_Record >;
	public import function MagnetismParamsHandle() : AimAssistMagnetism_Record;
	public import function BulletMagnetismParams() : weak< AimAssistBulletMagnetism_Record >;
	public import function BulletMagnetismParamsHandle() : AimAssistBulletMagnetism_Record;
	public import function AimSnapParams() : weak< AimAssistAimSnap_Record >;
	public import function AimSnapParamsHandle() : AimAssistAimSnap_Record;
	public import function CommonParams() : weak< AimAssistCommon_Record >;
	public import function CommonParamsHandle() : AimAssistCommon_Record;
	public import function FinishingParams() : weak< AimAssistFinishing_Record >;
	public import function FinishingParamsHandle() : AimAssistFinishing_Record;
	public import function MeleeParams() : weak< AimAssistMelee_Record >;
	public import function MeleeParamsHandle() : AimAssistMelee_Record;
}

importonly class AimAssistFinishing_Record extends TweakDBRecord
{
	public import function MaxTime() : Float;
	public import function MaxCorrectionYaw() : Float;
	public import function VelocityDecreaseActivationFactor() : Float;
	public import function InputHistoryTime() : Float;
	public import function MaxCorrectionAngle() : Float;
	public import function MaxCorrectionPitch() : Float;
	public import function IsEnabled() : Bool;
}

importonly class AimAssistMagnetism_Record extends TweakDBRecord
{
	public import function DistanceMultiplier() : CName;
	public import function StickInputMagMultiplier() : CName;
	public import function MaxStrength() : Vector2;
	public import function SoftLockMinimumMagnetism() : Float;
	public import function BlendOnTime() : Float;
	public import function BlendOffTime() : Float;
	public import function MaxTimeTillOffTarget() : Float;
	public import function MinTimeTillOffTarget() : Float;
	public import function SoftLockBlendInTime() : Float;
	public import function SoftLockTimeToReach() : Float;
	public import function PitchBoundAdditiveForYawMagnetism() : Float;
	public import function YawBoundAdditiveForPitchMagnetism() : Float;
	public import function FullStickThreshold() : Float;
	public import function FullStickYawAngleDisable() : Float;
	public import function TargetLostBlendOut() : Bool;
	public import function TrackedTargetAutoTargeting() : Bool;
	public import function IsEnabled() : Bool;
	public import function CheckWeaponEffectiveRange() : Bool;
	public import function DisableWithNoInput() : Bool;
}

importonly class AimAssistMelee_Record extends TweakDBRecord
{
	public import function MoveToTargetEnabledAttacks() : Int32;
	public import function MoveToTargetSearchDistance() : Float;
	public import function MoveToTargetDistanceIntoAttackRange() : Float;
	public import function AimSnapOnBlockHit() : Bool;
	public import function AimSnapOnAttack() : Bool;
	public import function AimSnapOnThrow() : Bool;
	public import function AimSnapOnAim() : Bool;
	public import function AimSnapOnHit() : Bool;
}

importonly class AimAssistSettings_Record extends TweakDBRecord
{
	public import function Off() : weak< AimAssistConfigPreset_Record >;
	public import function OffHandle() : AimAssistConfigPreset_Record;
	public import function Light() : weak< AimAssistConfigPreset_Record >;
	public import function LightHandle() : AimAssistConfigPreset_Record;
	public import function Standard() : weak< AimAssistConfigPreset_Record >;
	public import function StandardHandle() : AimAssistConfigPreset_Record;
	public import function Heavy() : weak< AimAssistConfigPreset_Record >;
	public import function HeavyHandle() : AimAssistConfigPreset_Record;
}

importonly class AimAssistTargetData_Record extends TweakDBRecord
{
	public import function Filters( out outList : array< weak< AimAssistType_Record > > );
	public import function GetFiltersCount() : Int32;
	public import function GetFiltersItem( index : Int32 ) : weak< AimAssistType_Record >;
	public import function GetFiltersItemHandle( index : Int32 ) : AimAssistType_Record;
	public import function FiltersContains( item : weak< AimAssistType_Record > ) : Bool;
	public import function HeightUp() : Float;
	public import function AimSnapAngle() : Float;
	public import function HeightDown() : Float;
	public import function Width() : Float;
	public import function AimSnapPriorityWeight() : Float;
	public import function MagnetismPriorityWeight() : Float;
	public import function IsForAimMagnetisim() : Bool;
	public import function IsForAimSnap() : Bool;
}

importonly class AimAssistType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAimAssistType;
}

importonly class AngleDistanceCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function AngleDistanceScore() : Float;
	public import function CoverLowerMinVerticalAngle() : Float;
	public import function MaximumDistance() : Float;
	public import function MinThreatsAmountToCheckDistance() : Int32;
	public import function CoverProtectionAngleMul() : Float;
	public import function ThreatPredictionTime() : Float;
	public import function VerticalAngleCooldown() : Float;
	public import function ShootingSpotLowerMinVerticalAngle() : Float;
	public import function ClosestThreatsAmountToIgnoreDistanceCheck() : Int32;
}

importonly class AngleRange_Record extends SenseShape_Record
{
	public import function Position() : Vector3;
	public import function Angle() : Float;
	public import function Range() : Float;
	public import function HalfHeight() : Float;
}

importonly class Appearance_Record extends TweakDBRecord
{
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
}

importonly class ApperanceToEthnicities_Record extends TweakDBRecord
{
	public import function Ethnicities( out outList : array< weak< EthnicNames_Record > > );
	public import function GetEthnicitiesCount() : Int32;
	public import function GetEthnicitiesItem( index : Int32 ) : weak< EthnicNames_Record >;
	public import function GetEthnicitiesItemHandle( index : Int32 ) : EthnicNames_Record;
	public import function EthnicitiesContains( item : weak< EthnicNames_Record > ) : Bool;
	public import function AppearanceName() : CName;
}

importonly class ApperanceToEthnicitiesMap_Record extends TweakDBRecord
{
	public import function Map( out outList : array< weak< ApperanceToEthnicities_Record > > );
	public import function GetMapCount() : Int32;
	public import function GetMapItem( index : Int32 ) : weak< ApperanceToEthnicities_Record >;
	public import function GetMapItemHandle( index : Int32 ) : ApperanceToEthnicities_Record;
	public import function MapContains( item : weak< ApperanceToEthnicities_Record > ) : Bool;
}

importonly class ApplyEffectorEffector_Record extends Effector_Record
{
	public import function EffectorToApply() : weak< Effector_Record >;
	public import function EffectorToApplyHandle() : Effector_Record;
	public import function ApplicationTarget() : CName;
}

importonly class ApplyLightPresetEffector_Record extends Effector_Record
{
	public import function LightPreset() : weak< LightPreset_Record >;
	public import function LightPresetHandle() : LightPreset_Record;
}

importonly class ApplyStatGroupEffector_Record extends Effector_Record
{
	public import function StatGroup() : weak< StatModifierGroup_Record >;
	public import function StatGroupHandle() : StatModifierGroup_Record;
	public import function ApplicationTarget() : CName;
	public import function RemoveWithEffector() : Bool;
}

importonly class ApplyStatusEffectBasedOnDifficultyEffector_Record extends ApplyStatusEffectEffector_Record
{
	public import function StatusEffectOnEasyDifficulty() : weak< StatusEffect_Record >;
	public import function StatusEffectOnEasyDifficultyHandle() : StatusEffect_Record;
	public import function StatusEffectOnStoryDifficulty() : weak< StatusEffect_Record >;
	public import function StatusEffectOnStoryDifficultyHandle() : StatusEffect_Record;
	public import function StatusEffectOnVeryHardDifficulty() : weak< StatusEffect_Record >;
	public import function StatusEffectOnVeryHardDifficultyHandle() : StatusEffect_Record;
	public import function StatusEffectOnHardDifficulty() : weak< StatusEffect_Record >;
	public import function StatusEffectOnHardDifficultyHandle() : StatusEffect_Record;
}

importonly class ApplyStatusEffectByChanceEffector_Record extends ApplyStatusEffectEffector_Record
{
	public import function EffectorChance( out outList : array< weak< StatModifier_Record > > );
	public import function GetEffectorChanceCount() : Int32;
	public import function GetEffectorChanceItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetEffectorChanceItemHandle( index : Int32 ) : StatModifier_Record;
	public import function EffectorChanceContains( item : weak< StatModifier_Record > ) : Bool;
}

importonly class ApplyStatusEffectByChanceEffector_inline0_Record extends ConstantStatModifier_Record
{
}

importonly class ApplyStatusEffectEffector_Record extends Effector_Record
{
	public import function Instigator() : String;
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function ApplicationTarget() : CName;
	public import function Count() : Float;
	public import function UseCountWhenRemoving() : Bool;
	public import function Inverted() : Bool;
	public import function RemoveWithEffector() : Bool;
}

importonly class ArcadeBackgroundLayer_Record extends TweakDBRecord
{
	public import function ImageTexturePartList() : array< CName >;
	public import function GetImageTexturePartListCount() : Int32;
	public import function GetImageTexturePartListItem( index : Int32 ) : CName;
	public import function ImageTexturePartListContains( item : CName ) : Bool;
	public import function ImageTextureAtlas() : ResRef;
}

importonly class ArcadeCollidableObject_Record extends ArcadeObject_Record
{
	public import function BoundingShapeRelativeArea() : Vector2;
}

importonly class ArcadeGameplay_Record extends TweakDBRecord
{
	public import function ArcadeGameplaySilentBackgroundMusic() : CName;
	public import function ArcadeGameplayPausedSFX() : CName;
}

importonly class ArcadeMenu_Record extends TweakDBRecord
{
	public import function ArcadeMenuOptionSelectedSFX() : CName;
	public import function ArcadeMenuOptionClickedSFX() : CName;
}

importonly class ArcadeMinigameData_Record extends TweakDBRecord
{
	public import function ArcadePermanentResourceList() : array< ResRef >;
	public import function GetArcadePermanentResourceListCount() : Int32;
	public import function GetArcadePermanentResourceListItem( index : Int32 ) : ResRef;
	public import function ArcadeGameplayScreenTDBID() : CName;
	public import function ArcadeStartBackgroundMusic() : CName;
	public import function ArcadeScoreboardScreenTDBID() : CName;
	public import function ArcadeStopBackgroundMusic() : CName;
	public import function ArcadeMenuScreenTDBID() : CName;
	public import function ArcadeStopSFXs() : CName;
}

importonly class ArcadeMinigameDataList_Record extends TweakDBRecord
{
	public import function Data( out outList : array< weak< ArcadeMinigameData_Record > > );
	public import function GetDataCount() : Int32;
	public import function GetDataItem( index : Int32 ) : weak< ArcadeMinigameData_Record >;
	public import function GetDataItemHandle( index : Int32 ) : ArcadeMinigameData_Record;
	public import function DataContains( item : weak< ArcadeMinigameData_Record > ) : Bool;
}

importonly class ArcadeObject_Record extends TweakDBRecord
{
	public import function ImageTextureAtlas() : ResRef;
	public import function ImageTexturePart() : CName;
	public import function Name() : CName;
	public import function Animation() : CName;
	public import function ImageAnchorPoint() : Vector2;
}

importonly class ArcadeScoreboard_Record extends TweakDBRecord
{
	public import function ArcadeScoreboardEntryList( out outList : array< weak< ArcadeScoreboardEntry_Record > > );
	public import function GetArcadeScoreboardEntryListCount() : Int32;
	public import function GetArcadeScoreboardEntryListItem( index : Int32 ) : weak< ArcadeScoreboardEntry_Record >;
	public import function GetArcadeScoreboardEntryListItemHandle( index : Int32 ) : ArcadeScoreboardEntry_Record;
	public import function ArcadeScoreboardEntryListContains( item : weak< ArcadeScoreboardEntry_Record > ) : Bool;
	public import function ArcadeScoreboardQuestFactList() : array< CName >;
	public import function GetArcadeScoreboardQuestFactListCount() : Int32;
	public import function GetArcadeScoreboardQuestFactListItem( index : Int32 ) : CName;
	public import function ArcadeScoreboardQuestFactListContains( item : CName ) : Bool;
	public import function ArcadeScoreboardHighScoreSFX() : CName;
}

importonly class ArcadeScoreboardEntry_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Score() : Float;
}

importonly class ArcadeSpawnableID_Record extends TweakDBRecord
{
	public import function Id() : CName;
	public import function Probability() : Float;
}

importonly class ArcadeSpawnableObject_Record extends TweakDBRecord
{
	public import function Object() : weak< ArcadeObject_Record >;
	public import function ObjectHandle() : ArcadeObject_Record;
	public import function Probability() : Float;
}

importonly class ArchetypeData_Record extends TweakDBRecord
{
	public import function Type() : weak< ArchetypeType_Record >;
	public import function TypeHandle() : ArchetypeType_Record;
	public import function StatModifierGroups( out outList : array< weak< StatModifierGroup_Record > > );
	public import function GetStatModifierGroupsCount() : Int32;
	public import function GetStatModifierGroupsItem( index : Int32 ) : weak< StatModifierGroup_Record >;
	public import function GetStatModifierGroupsItemHandle( index : Int32 ) : StatModifierGroup_Record;
	public import function StatModifierGroupsContains( item : weak< StatModifierGroup_Record > ) : Bool;
	public import function AbilityGroups( out outList : array< weak< GameplayAbilityGroup_Record > > );
	public import function GetAbilityGroupsCount() : Int32;
	public import function GetAbilityGroupsItem( index : Int32 ) : weak< GameplayAbilityGroup_Record >;
	public import function GetAbilityGroupsItemHandle( index : Int32 ) : GameplayAbilityGroup_Record;
	public import function AbilityGroupsContains( item : weak< GameplayAbilityGroup_Record > ) : Bool;
	public import function ShootingPatternPackages( out outList : array< weak< AIPatternsPackage_Record > > );
	public import function GetShootingPatternPackagesCount() : Int32;
	public import function GetShootingPatternPackagesItem( index : Int32 ) : weak< AIPatternsPackage_Record >;
	public import function GetShootingPatternPackagesItemHandle( index : Int32 ) : AIPatternsPackage_Record;
	public import function ShootingPatternPackagesContains( item : weak< AIPatternsPackage_Record > ) : Bool;
}

importonly class ArchetypeType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function LocalizedName() : CName;
	public import function EnumName() : CName;
	public import function Type() : gamedataArchetypeType;
}

importonly class AttachableObject_Record extends SpawnableObject_Record
{
}

importonly class AttachmentSlot_Record extends TweakDBRecord
{
	public import function EntitySlotName() : String;
	public import function LocalizedName() : String;
	public import function TagsForActiveItemCycling() : array< CName >;
	public import function GetTagsForActiveItemCyclingCount() : Int32;
	public import function GetTagsForActiveItemCyclingItem( index : Int32 ) : CName;
	public import function TagsForActiveItemCyclingContains( item : CName ) : Bool;
	public import function CustomOffset() : Vector3;
}

importonly class Attack_Record extends TweakDBRecord
{
	public import function UserDataPath() : String;
	public import function DamageType() : weak< DamageType_Record >;
	public import function DamageTypeHandle() : DamageType_Record;
	public import function AttackType() : weak< AttackType_Record >;
	public import function AttackTypeHandle() : AttackType_Record;
	public import function StatusEffects( out outList : array< weak< StatusEffectAttackData_Record > > );
	public import function GetStatusEffectsCount() : Int32;
	public import function GetStatusEffectsItem( index : Int32 ) : weak< StatusEffectAttackData_Record >;
	public import function GetStatusEffectsItemHandle( index : Int32 ) : StatusEffectAttackData_Record;
	public import function StatusEffectsContains( item : weak< StatusEffectAttackData_Record > ) : Bool;
	public import function HitFlags() : array< String >;
	public import function GetHitFlagsCount() : Int32;
	public import function GetHitFlagsItem( index : Int32 ) : String;
	public import function HitFlagsContains( item : String ) : Bool;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function StaminaCost( out outList : array< weak< StatModifier_Record > > );
	public import function GetStaminaCostCount() : Int32;
	public import function GetStaminaCostItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStaminaCostItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StaminaCostContains( item : weak< StatModifier_Record > ) : Bool;
	public import function ClassName() : CName;
	public import function AttackName() : CName;
	public import function PlayerIncomingDamageMultiplier() : Float;
	public import function Velocity() : Float;
	public import function Range() : Float;
	public import function HitReactionSeverityMin() : Int32;
	public import function HitReactionSeverityMax() : Int32;
	public import function ExplosionDamageVSVehicles() : Float;
	public import function UseDefaultAimData() : Bool;
}

importonly class AttackDirection_Record extends TweakDBRecord
{
	public import function Direction() : weak< MeleeAttackDirection_Record >;
	public import function DirectionHandle() : MeleeAttackDirection_Record;
	public import function StartPosition() : Vector3;
	public import function MiddlePosition() : Vector3;
	public import function EndPosition() : Vector3;
	public import function UseMiddlePosition() : Bool;
	public import function IsThrust() : Bool;
}

importonly class AttackSubtype_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataAttackSubtype;
}

importonly class AttackType_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Comment() : String;
	public import function Type() : gamedataAttackType;
}

importonly class Attack_GameEffect_Record extends Attack_Record
{
	public import function ExplosionAttack() : weak< Attack_GameEffect_Record >;
	public import function ExplosionAttackHandle() : Attack_GameEffect_Record;
	public import function EffectName() : CName;
	public import function AttackTag() : CName;
	public import function EffectTag() : CName;
	public import function AudioTag() : CName;
	public import function AudioAttackIndex() : Float;
}

importonly class Attack_Landing_Record extends Attack_GameEffect_Record
{
	public import function FxPackage() : weak< LandingFxPackage_Record >;
	public import function FxPackageHandle() : LandingFxPackage_Record;
}

importonly class Attack_Melee_Record extends Attack_GameEffect_Record
{
	public import function TrailAttackSide() : String;
	public import function AttackDirection() : weak< AttackDirection_Record >;
	public import function AttackDirectionHandle() : AttackDirection_Record;
	public import function AttackSubtype() : weak< AttackSubtype_Record >;
	public import function AttackSubtypeHandle() : AttackSubtype_Record;
	public import function VfxName() : CName;
	public import function ImpactFxSlot() : CName;
	public import function IkOffset() : Vector3;
	public import function UpImpulse() : Float;
	public import function Duration() : Float;
	public import function TrailStartDelay() : Float;
	public import function RecoverDuration() : Float;
	public import function CameraSpaceImpulse() : Float;
	public import function StartupDuration() : Float;
	public import function ActiveHitDuration() : Float;
	public import function RecoverHitDuration() : Float;
	public import function Radius() : Float;
	public import function AttackEffectDuration() : Float;
	public import function TrailStopDelay() : Float;
	public import function ImpulseDelay() : Float;
	public import function BlockTransitionTime() : Float;
	public import function AttackEffectDelay() : Float;
	public import function IdleTransitionTime() : Float;
	public import function SpawnDistance() : Float;
	public import function HoldTransitionTime() : Float;
	public import function AttackWindowOpen() : Float;
	public import function WeaponChargeCost() : Float;
	public import function ForwardImpulse() : Float;
	public import function BlockCostFactor() : Float;
	public import function ActiveDuration() : Float;
	public import function AttackWindowClosed() : Float;
	public import function StandUpDelay() : Float;
	public import function CanSkipBlock() : Bool;
	public import function DontScaleWithAttackSpeed() : Bool;
	public import function HasDeflectAnim() : Bool;
	public import function IncrementsCombo() : Bool;
	public import function UseAdjustmentInsteadOfImpulse() : Bool;
	public import function HasHitAnim() : Bool;
	public import function EnableAdjustingPlayerPositionToTarget() : Bool;
}

importonly class Attack_Projectile_Record extends Attack_Record
{
	public import function ExplosionAttack() : weak< Attack_GameEffect_Record >;
	public import function ExplosionAttackHandle() : Attack_GameEffect_Record;
	public import function ProjectileTemplateName() : CName;
}

importonly class Attitude_Record extends TweakDBRecord
{
	public import function Value() : String;
	public import function Group1() : weak< AttitudeGroup_Record >;
	public import function Group1Handle() : AttitudeGroup_Record;
	public import function Group2() : weak< AttitudeGroup_Record >;
	public import function Group2Handle() : AttitudeGroup_Record;
}

importonly class AttitudeGroup_Record extends TweakDBRecord
{
	public import function DefaultAttitude() : String;
	public import function AttitudeToSelf() : String;
	public import function Parent() : weak< AttitudeGroup_Record >;
	public import function ParentHandle() : AttitudeGroup_Record;
	public import function Name() : CName;
	public import function IsState() : Bool;
}

importonly class Attribute_Record extends Stat_Record
{
	public import function Proficiencies( out outList : array< weak< Proficiency_Record > > );
	public import function GetProficienciesCount() : Int32;
	public import function GetProficienciesItem( index : Int32 ) : weak< Proficiency_Record >;
	public import function GetProficienciesItemHandle( index : Int32 ) : Proficiency_Record;
	public import function ProficienciesContains( item : weak< Proficiency_Record > ) : Bool;
}

importonly class AttributeData_Record extends TweakDBRecord
{
	public import function Loc_desc_key() : String;
	public import function EnumComment() : String;
	public import function Loc_name_key() : String;
	public import function AttrIcon() : weak< UIIcon_Record >;
	public import function AttrIconHandle() : UIIcon_Record;
	public import function Attribute() : weak< Attribute_Record >;
	public import function AttributeHandle() : Attribute_Record;
	public import function Perks( out outList : array< weak< NewPerk_Record > > );
	public import function GetPerksCount() : Int32;
	public import function GetPerksItem( index : Int32 ) : weak< NewPerk_Record >;
	public import function GetPerksItemHandle( index : Int32 ) : NewPerk_Record;
	public import function PerksContains( item : weak< NewPerk_Record > ) : Bool;
	public import function EnumName() : CName;
	public import function Type() : gamedataAttributeDataType;
}

importonly class AvoidLineOfSightSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function Angle() : Float;
	public import function Multiplier() : Float;
	public import function Height() : Float;
	public import function Distance() : Float;
}

importonly class BaseDrivingParameters_Record extends TweakDBRecord
{
	public import function Brake() : weak< VehiclePIDSettings_Record >;
	public import function BrakeHandle() : VehiclePIDSettings_Record;
	public import function Stopping() : weak< VehicleStoppingSettings_Record >;
	public import function StoppingHandle() : VehicleStoppingSettings_Record;
	public import function BoostStats() : weak< VehicleAIBoostSettings_Record >;
	public import function BoostStatsHandle() : VehicleAIBoostSettings_Record;
	public import function Accel() : weak< VehiclePIDSettings_Record >;
	public import function AccelHandle() : VehiclePIDSettings_Record;
	public import function SteeringReverse() : weak< VehicleSteeringSettings_Record >;
	public import function SteeringReverseHandle() : VehicleSteeringSettings_Record;
	public import function Steering() : weak< VehicleSteeringSettings_Record >;
	public import function SteeringHandle() : VehicleSteeringSettings_Record;
	public import function Vision() : weak< VehicleAIVisionSettings_Record >;
	public import function VisionHandle() : VehicleAIVisionSettings_Record;
	public import function Traction() : weak< VehicleAITractionEstimation_Record >;
	public import function TractionHandle() : VehicleAITractionEstimation_Record;
	public import function Panic() : weak< VehicleAIPanicDrivingSettings_Record >;
	public import function PanicHandle() : VehicleAIPanicDrivingSettings_Record;
}

importonly class BaseObject_Record extends TweakDBRecord
{
	public import function StatModifierGroups( out outList : array< weak< StatModifierGroup_Record > > );
	public import function GetStatModifierGroupsCount() : Int32;
	public import function GetStatModifierGroupsItem( index : Int32 ) : weak< StatModifierGroup_Record >;
	public import function GetStatModifierGroupsItemHandle( index : Int32 ) : StatModifierGroup_Record;
	public import function StatModifierGroupsContains( item : weak< StatModifierGroup_Record > ) : Bool;
	public import function Effectors( out outList : array< weak< Effector_Record > > );
	public import function GetEffectorsCount() : Int32;
	public import function GetEffectorsItem( index : Int32 ) : weak< Effector_Record >;
	public import function GetEffectorsItemHandle( index : Int32 ) : Effector_Record;
	public import function EffectorsContains( item : weak< Effector_Record > ) : Bool;
	public import function StatPools( out outList : array< weak< StatPool_Record > > );
	public import function GetStatPoolsCount() : Int32;
	public import function GetStatPoolsItem( index : Int32 ) : weak< StatPool_Record >;
	public import function GetStatPoolsItemHandle( index : Int32 ) : StatPool_Record;
	public import function StatPoolsContains( item : weak< StatPool_Record > ) : Bool;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function Weakspots( out outList : array< weak< Weakspot_Record > > );
	public import function GetWeakspotsCount() : Int32;
	public import function GetWeakspotsItem( index : Int32 ) : weak< Weakspot_Record >;
	public import function GetWeakspotsItemHandle( index : Int32 ) : Weakspot_Record;
	public import function WeakspotsContains( item : weak< Weakspot_Record > ) : Bool;
	public import function ObjectActions( out outList : array< weak< ObjectAction_Record > > );
	public import function GetObjectActionsCount() : Int32;
	public import function GetObjectActionsItem( index : Int32 ) : weak< ObjectAction_Record >;
	public import function GetObjectActionsItemHandle( index : Int32 ) : ObjectAction_Record;
	public import function ObjectActionsContains( item : weak< ObjectAction_Record > ) : Bool;
	public import function Savable() : Bool;
}

importonly class BaseSign_Record extends TweakDBRecord
{
	public import function Resource() : ResRef;
	public import function StyleStateName() : CName;
	public import function IsUnique() : Bool;
}

importonly class Base_MappinDefinition_Record extends TweakDBRecord
{
	public import function VisibilityRange() : Float;
	public import function ShowOnMinimap() : Bool;
	public import function ShowOnMap() : Bool;
	public import function ShowInWorld() : Bool;
}

importonly class BikeDriveModelData_Record extends VehicleDriveModelData_Record
{
	public import function BikeTiltPID() : array< Float >;
	public import function GetBikeTiltPIDCount() : Int32;
	public import function GetBikeTiltPIDItem( index : Int32 ) : Float;
	public import function BikeTiltPIDContains( item : Float ) : Bool;
	public import function BikeCurvesPath() : ResRef;
	public import function BikeMaxCOMLongOffset() : Float;
	public import function BikeCOMOffsetDampFactor() : Float;
	public import function BikeTiltSpeed() : Float;
	public import function BikeTiltCustomSpeed() : Float;
	public import function BikeTiltReturnSpeed() : Float;
	public import function BikeMinCOMLongOffset() : Float;
	public import function BikeMaxTilt() : Float;
}

importonly class Bounce_Record extends ProjectileCollision_Record
{
}

importonly class Bounty_Record extends TweakDBRecord
{
	public import function BountySetter() : weak< Affiliation_Record >;
	public import function BountySetterHandle() : Affiliation_Record;
	public import function Reward() : weak< RewardBase_Record >;
	public import function RewardHandle() : RewardBase_Record;
	public import function VisualTagsFilter() : array< CName >;
	public import function GetVisualTagsFilterCount() : Int32;
	public import function GetVisualTagsFilterItem( index : Int32 ) : CName;
	public import function VisualTagsFilterContains( item : CName ) : Bool;
	public import function Transgressions( out outList : array< weak< Transgression_Record > > );
	public import function GetTransgressionsCount() : Int32;
	public import function GetTransgressionsItem( index : Int32 ) : weak< Transgression_Record >;
	public import function GetTransgressionsItemHandle( index : Int32 ) : Transgression_Record;
	public import function TransgressionsContains( item : weak< Transgression_Record > ) : Bool;
	public import function DrawWeight() : Float;
	public import function WantedStars() : Int32;
}

importonly class BountyDrawTable_Record extends TweakDBRecord
{
	public import function BountyChoices( out outList : array< weak< Bounty_Record > > );
	public import function GetBountyChoicesCount() : Int32;
	public import function GetBountyChoicesItem( index : Int32 ) : weak< Bounty_Record >;
	public import function GetBountyChoicesItemHandle( index : Int32 ) : Bounty_Record;
	public import function BountyChoicesContains( item : weak< Bounty_Record > ) : Bool;
}

importonly class Box_Record extends SenseShape_Record
{
	public import function Min() : Vector3;
	public import function Max() : Vector3;
}

importonly class BroadcastStimEffector_Record extends ContinuousEffector_Record
{
	public import function Type() : weak< StimType_Record >;
	public import function TypeHandle() : StimType_Record;
	public import function Radius() : Float;
}

importonly class BuildAttribute_Record extends TweakDBRecord
{
	public import function Attribute() : weak< Attribute_Record >;
	public import function AttributeHandle() : Attribute_Record;
	public import function Level() : Int32;
}

importonly class BuildAttributeSet_Record extends TweakDBRecord
{
	public import function Attributes( out outList : array< weak< BuildAttribute_Record > > );
	public import function GetAttributesCount() : Int32;
	public import function GetAttributesItem( index : Int32 ) : weak< BuildAttribute_Record >;
	public import function GetAttributesItemHandle( index : Int32 ) : BuildAttribute_Record;
	public import function AttributesContains( item : weak< BuildAttribute_Record > ) : Bool;
}

importonly class BuildCyberware_Record extends TweakDBRecord
{
	public import function Cyberware() : weak< Item_Record >;
	public import function CyberwareHandle() : Item_Record;
}

importonly class BuildCyberwareSet_Record extends TweakDBRecord
{
	public import function Cyberware( out outList : array< weak< BuildCyberware_Record > > );
	public import function GetCyberwareCount() : Int32;
	public import function GetCyberwareItem( index : Int32 ) : weak< BuildCyberware_Record >;
	public import function GetCyberwareItemHandle( index : Int32 ) : BuildCyberware_Record;
	public import function CyberwareContains( item : weak< BuildCyberware_Record > ) : Bool;
	public import function Programs( out outList : array< weak< BuildProgram_Record > > );
	public import function GetProgramsCount() : Int32;
	public import function GetProgramsItem( index : Int32 ) : weak< BuildProgram_Record >;
	public import function GetProgramsItemHandle( index : Int32 ) : BuildProgram_Record;
	public import function ProgramsContains( item : weak< BuildProgram_Record > ) : Bool;
}

importonly class BuildEquipment_Record extends TweakDBRecord
{
	public import function Equipment() : weak< Item_Record >;
	public import function EquipmentHandle() : Item_Record;
}

importonly class BuildEquipmentSet_Record extends TweakDBRecord
{
	public import function Equipment( out outList : array< weak< BuildEquipment_Record > > );
	public import function GetEquipmentCount() : Int32;
	public import function GetEquipmentItem( index : Int32 ) : weak< BuildEquipment_Record >;
	public import function GetEquipmentItemHandle( index : Int32 ) : BuildEquipment_Record;
	public import function EquipmentContains( item : weak< BuildEquipment_Record > ) : Bool;
}

importonly class BuildNewPerk_Record extends TweakDBRecord
{
	public import function Perk() : weak< NewPerk_Record >;
	public import function PerkHandle() : NewPerk_Record;
	public import function Level() : Int32;
	public import function IsActive() : Bool;
}

importonly class BuildPerk_Record extends TweakDBRecord
{
	public import function Perk() : weak< Perk_Record >;
	public import function PerkHandle() : Perk_Record;
	public import function Level() : Int32;
	public import function IsActive() : Bool;
}

importonly class BuildPerkSet_Record extends TweakDBRecord
{
	public import function Perks( out outList : array< weak< BuildPerk_Record > > );
	public import function GetPerksCount() : Int32;
	public import function GetPerksItem( index : Int32 ) : weak< BuildPerk_Record >;
	public import function GetPerksItemHandle( index : Int32 ) : BuildPerk_Record;
	public import function PerksContains( item : weak< BuildPerk_Record > ) : Bool;
}

importonly class BuildProficiency_Record extends TweakDBRecord
{
	public import function Proficiency() : weak< Proficiency_Record >;
	public import function ProficiencyHandle() : Proficiency_Record;
	public import function Level() : Int32;
}

importonly class BuildProficiencySet_Record extends TweakDBRecord
{
	public import function Proficiencies( out outList : array< weak< BuildProficiency_Record > > );
	public import function GetProficienciesCount() : Int32;
	public import function GetProficienciesItem( index : Int32 ) : weak< BuildProficiency_Record >;
	public import function GetProficienciesItemHandle( index : Int32 ) : BuildProficiency_Record;
	public import function ProficienciesContains( item : weak< BuildProficiency_Record > ) : Bool;
}

importonly class BuildProgram_Record extends TweakDBRecord
{
	public import function Program() : weak< Item_Record >;
	public import function ProgramHandle() : Item_Record;
}

importonly class CPOItemCategoryBase_Record extends TweakDBRecord
{
}

importonly class CPOLoadoutBase_Record extends TweakDBRecord
{
	public import function DisplayName() : String;
	public import function Items( out outList : array< weak< InventoryItem_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< InventoryItem_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : InventoryItem_Record;
	public import function ItemsContains( item : weak< InventoryItem_Record > ) : Bool;
}

importonly class CarriableObject_Record extends SpawnableObject_Record
{
}

importonly class ChannelData_Record extends TweakDBRecord
{
	public import function LocalizedName() : String;
	public import function DynamicTexturePath() : String;
	public import function OverlayWidgetPath() : String;
	public import function ChannelWidget() : CName;
	public import function AudioEvent() : CName;
	public import function OrderID() : Int32;
}

importonly class Character_Record extends SpawnableObject_Record
{
	public import function CpoCharacterBuild() : String;
	public import function DevNotes() : String;
	public import function VendorID() : weak< Vendor_Record >;
	public import function VendorIDHandle() : Vendor_Record;
	public import function Driving() : weak< BaseDrivingParameters_Record >;
	public import function DrivingHandle() : BaseDrivingParameters_Record;
	public import function LootDrop() : weak< LootTable_Record >;
	public import function LootDropHandle() : LootTable_Record;
	public import function SquadParamsID() : weak< AISquadParams_Record >;
	public import function SquadParamsIDHandle() : AISquadParams_Record;
	public import function SecondaryEquipment() : weak< NPCEquipmentGroup_Record >;
	public import function SecondaryEquipmentHandle() : NPCEquipmentGroup_Record;
	public import function CharacterType() : weak< NPCType_Record >;
	public import function CharacterTypeHandle() : NPCType_Record;
	public import function PrimaryEquipment() : weak< NPCEquipmentGroup_Record >;
	public import function PrimaryEquipmentHandle() : NPCEquipmentGroup_Record;
	public import function LootInjectionParams() : weak< LootInjectionSettings_Record >;
	public import function LootInjectionParamsHandle() : LootInjectionSettings_Record;
	public import function UiNameplate() : weak< UINameplate_Record >;
	public import function UiNameplateHandle() : UINameplate_Record;
	public import function DefaultEquipment() : weak< NPCEquipmentItem_Record >;
	public import function DefaultEquipmentHandle() : NPCEquipmentItem_Record;
	public import function CrowdMemberSettings() : weak< CrowdSettingsPackageBase_Record >;
	public import function CrowdMemberSettingsHandle() : CrowdSettingsPackageBase_Record;
	public import function Rarity() : weak< NPCRarity_Record >;
	public import function RarityHandle() : NPCRarity_Record;
	public import function ActionMap() : weak< ActionMap_Record >;
	public import function ActionMapHandle() : ActionMap_Record;
	public import function DefaultCrosshair() : weak< Crosshair_Record >;
	public import function DefaultCrosshairHandle() : Crosshair_Record;
	public import function SensePreset() : weak< SensePreset_Record >;
	public import function SensePresetHandle() : SensePreset_Record;
	public import function ContentAssignment() : weak< ContentAssignment_Record >;
	public import function ContentAssignmentHandle() : ContentAssignment_Record;
	public import function ReactionPreset() : weak< ReactionPreset_Record >;
	public import function ReactionPresetHandle() : ReactionPreset_Record;
	public import function IdleActions() : weak< AIActionSmartComposite_Record >;
	public import function IdleActionsHandle() : AIActionSmartComposite_Record;
	public import function ScannerModulePreset() : weak< ScannerModuleVisibilityPreset_Record >;
	public import function ScannerModulePresetHandle() : ScannerModuleVisibilityPreset_Record;
	public import function Quest() : weak< NPCQuestAffiliation_Record >;
	public import function QuestHandle() : NPCQuestAffiliation_Record;
	public import function ArchetypeData() : weak< ArchetypeData_Record >;
	public import function ArchetypeDataHandle() : ArchetypeData_Record;
	public import function Affiliation() : weak< Affiliation_Record >;
	public import function AffiliationHandle() : Affiliation_Record;
	public import function ThreatTrackingPreset() : weak< ThreatTrackingPresetBase_Record >;
	public import function ThreatTrackingPresetHandle() : ThreatTrackingPresetBase_Record;
	public import function BountyDrawTable() : weak< BountyDrawTable_Record >;
	public import function BountyDrawTableHandle() : BountyDrawTable_Record;
	public import function MinigameInstance() : weak< Minigame_Def_Record >;
	public import function MinigameInstanceHandle() : Minigame_Def_Record;
	public import function OnSpawnGLPs( out outList : array< weak< GameplayLogicPackage_Record > > );
	public import function GetOnSpawnGLPsCount() : Int32;
	public import function GetOnSpawnGLPsItem( index : Int32 ) : weak< GameplayLogicPackage_Record >;
	public import function GetOnSpawnGLPsItemHandle( index : Int32 ) : GameplayLogicPackage_Record;
	public import function OnSpawnGLPsContains( item : weak< GameplayLogicPackage_Record > ) : Bool;
	public import function Genders( out outList : array< weak< GenderEntity_Record > > );
	public import function GetGendersCount() : Int32;
	public import function GetGendersItem( index : Int32 ) : weak< GenderEntity_Record >;
	public import function GetGendersItemHandle( index : Int32 ) : GenderEntity_Record;
	public import function GendersContains( item : weak< GenderEntity_Record > ) : Bool;
	public import function Items( out outList : array< weak< InventoryItem_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< InventoryItem_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : InventoryItem_Record;
	public import function ItemsContains( item : weak< InventoryItem_Record > ) : Bool;
	public import function CrowdAppearanceNames() : array< CName >;
	public import function GetCrowdAppearanceNamesCount() : Int32;
	public import function GetCrowdAppearanceNamesItem( index : Int32 ) : CName;
	public import function CrowdAppearanceNamesContains( item : CName ) : Bool;
	public import function BossHealthBarThresholds() : array< Float >;
	public import function GetBossHealthBarThresholdsCount() : Int32;
	public import function GetBossHealthBarThresholdsItem( index : Int32 ) : Float;
	public import function BossHealthBarThresholdsContains( item : Float ) : Bool;
	public import function EquipmentAreas( out outList : array< weak< EquipmentArea_Record > > );
	public import function GetEquipmentAreasCount() : Int32;
	public import function GetEquipmentAreasItem( index : Int32 ) : weak< EquipmentArea_Record >;
	public import function GetEquipmentAreasItemHandle( index : Int32 ) : EquipmentArea_Record;
	public import function EquipmentAreasContains( item : weak< EquipmentArea_Record > ) : Bool;
	public import function AttachmentSlots( out outList : array< weak< AttachmentSlot_Record > > );
	public import function GetAttachmentSlotsCount() : Int32;
	public import function GetAttachmentSlotsItem( index : Int32 ) : weak< AttachmentSlot_Record >;
	public import function GetAttachmentSlotsItemHandle( index : Int32 ) : AttachmentSlot_Record;
	public import function AttachmentSlotsContains( item : weak< AttachmentSlot_Record > ) : Bool;
	public import function ItemGroups( out outList : array< weak< InventoryItemGroup_Record > > );
	public import function GetItemGroupsCount() : Int32;
	public import function GetItemGroupsItem( index : Int32 ) : weak< InventoryItemGroup_Record >;
	public import function GetItemGroupsItemHandle( index : Int32 ) : InventoryItemGroup_Record;
	public import function ItemGroupsContains( item : weak< InventoryItemGroup_Record > ) : Bool;
	public import function Abilities( out outList : array< weak< GameplayAbility_Record > > );
	public import function GetAbilitiesCount() : Int32;
	public import function GetAbilitiesItem( index : Int32 ) : weak< GameplayAbility_Record >;
	public import function GetAbilitiesItemHandle( index : Int32 ) : GameplayAbility_Record;
	public import function AbilitiesContains( item : weak< GameplayAbility_Record > ) : Bool;
	public import function SecuritySquad() : CName;
	public import function DisplayName() : CName;
	public import function LootBagEntity() : CName;
	public import function GlobalSquad() : CName;
	public import function ArchetypeName() : CName;
	public import function AudioResourceName() : CName;
	public import function CommunitySquad() : CName;
	public import function DisplayDescription() : CName;
	public import function AlternativeDisplayName() : CName;
	public import function StateMachineName() : CName;
	public import function BaseAttitudeGroup() : CName;
	public import function AlternativeFullDisplayName() : CName;
	public import function AudioMeleeMaterial() : CName;
	public import function FullDisplayName() : CName;
	public import function CpoClassName() : CName;
	public import function VoiceTag() : CName;
	public import function HolocallInitializerPath() : ResRef;
	public import function DropsAmmoOnDeathChance() : Float;
	public import function ForcedTBHZOffset() : Float;
	public import function IsChild() : Bool;
	public import function DespawnChildCommunityWhenPlayerInVehicle() : Bool;
	public import function DisableDefeatedState() : Bool;
	public import function IsCrowd() : Bool;
	public import function HideUIElements() : Bool;
	public import function HideUIDetection() : Bool;
	public import function IgnoreDetectionForAudioCue() : Bool;
	public import function CanHaveGenericTalk() : Bool;
	public import function DropsControlledLoot() : Bool;
	public import function DropsWeaponOnDeath() : Bool;
	public import function StaticCommunityAppearancesDistributionEnabled() : Bool;
	public import function IsBumpable() : Bool;
	public import function IsLightCrowd() : Bool;
	public import function ForceCanHaveGenericTalk() : Bool;
	public import function EnableSensesOnStart() : Bool;
	public import function HasDirectionalStarts() : Bool;
	public import function DropsMoneyOnDeath() : Bool;
	public import function UseForcedTBHZOffset() : Bool;
	public import function SkipDisplayArchetype() : Bool;
}

importonly class CharacterEntry_Record extends TweakDBRecord
{
	public import function Name() : CName;
	public import function Id() : Int32;
}

importonly class CharacterList_Record extends TweakDBRecord
{
	public import function Entries( out outList : array< weak< CharacterEntry_Record > > );
	public import function GetEntriesCount() : Int32;
	public import function GetEntriesItem( index : Int32 ) : weak< CharacterEntry_Record >;
	public import function GetEntriesItemHandle( index : Int32 ) : CharacterEntry_Record;
	public import function EntriesContains( item : weak< CharacterEntry_Record > ) : Bool;
}

importonly class ChatterHelperRadius_Record extends TweakDBRecord
{
	public import function MinDistanceToOtherPlayer() : Float;
	public import function MaxDistanceToOtherPlayer() : Float;
}

importonly class CheckType_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataCheckType;
}

importonly class ChoiceCaptionIconPart_Record extends ChoiceCaptionPart_Record
{
	public import function Comment() : String;
	public import function TexturePartID() : weak< UIIcon_Record >;
	public import function TexturePartIDHandle() : UIIcon_Record;
	public import function MappinVariant() : weak< MappinVariant_Record >;
	public import function MappinVariantHandle() : MappinVariant_Record;
	public import function EnumName() : CName;
}

importonly class ChoiceCaptionPart_Record extends TweakDBRecord
{
	public import function PartType() : weak< ChoiceCaptionPartType_Record >;
	public import function PartTypeHandle() : ChoiceCaptionPartType_Record;
}

importonly class ChoiceCaptionPartType_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataChoiceCaptionPartType;
}

importonly class ChoiceCaptionTagPart_Record extends ChoiceCaptionPart_Record
{
	public import function TagLocId() : String;
}

importonly class ClearLineOfSightCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function Cooldown() : Float;
	public import function Multiplier() : Float;
	public import function ClearLOSDistanceTolerance() : Float;
	public import function PreferredActionCount() : Int32;
}

importonly class ClosestToOwnerCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function PreferredOwnerDistance() : Float;
	public import function DistanceToOwnerMultiplier() : Float;
}

importonly class Clothing_Record extends Item_Record
{
}

importonly class Clothing_inline0_Record extends ConstantStatModifier_Record
{
}

importonly class Codex_Record extends TweakDBRecord
{
	public import function Entries( out outList : array< weak< CodexRecord_Record > > );
	public import function GetEntriesCount() : Int32;
	public import function GetEntriesItem( index : Int32 ) : weak< CodexRecord_Record >;
	public import function GetEntriesItemHandle( index : Int32 ) : CodexRecord_Record;
	public import function EntriesContains( item : weak< CodexRecord_Record > ) : Bool;
}

importonly class CodexRecord_Record extends TweakDBRecord
{
	public import function RecordContent( out outList : array< weak< CodexRecordPart_Record > > );
	public import function GetRecordContentCount() : Int32;
	public import function GetRecordContentItem( index : Int32 ) : weak< CodexRecordPart_Record >;
	public import function GetRecordContentItemHandle( index : Int32 ) : CodexRecordPart_Record;
	public import function RecordContentContains( item : weak< CodexRecordPart_Record > ) : Bool;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function UnlockPrereq() : CName;
	public import function UnlockedFromStart() : Bool;
}

importonly class CodexRecordPart_Record extends TweakDBRecord
{
	public import function PartContent() : String;
	public import function PartName() : CName;
}

importonly class CombinedStatModifier_Record extends StatModifier_Record
{
	public import function RefStat() : weak< Stat_Record >;
	public import function RefStatHandle() : Stat_Record;
	public import function RefObject() : CName;
	public import function OpSymbol() : CName;
	public import function Value() : Float;
}

importonly class CompanionDistancePreset_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Distance() : Float;
	public import function Tolerance() : Float;
	public import function Type() : gamedataCompanionDistancePreset;
}

importonly class CompoundSelectionPreset_Record extends TweakDBRecord
{
	public import function Presets() : array< String >;
	public import function GetPresetsCount() : Int32;
	public import function GetPresetsItem( index : Int32 ) : String;
	public import function PresetsContains( item : String ) : Bool;
	public import function GatherRadius() : Float;
}

importonly class ComputerScreenType_Record extends DeviceScreenType_Record
{
}

importonly class ComputerStyleUIDefinition_Record extends TweakDBRecord
{
	public import function MailWidget() : weak< WidgetDefinition_Record >;
	public import function MailWidgetHandle() : WidgetDefinition_Record;
	public import function BannerWidget() : weak< WidgetDefinition_Record >;
	public import function BannerWidgetHandle() : WidgetDefinition_Record;
	public import function MailThumbnailWidget() : weak< WidgetDefinition_Record >;
	public import function MailThumbnailWidgetHandle() : WidgetDefinition_Record;
	public import function MenuButtonWidget() : weak< WidgetDefinition_Record >;
	public import function MenuButtonWidgetHandle() : WidgetDefinition_Record;
	public import function FileThumbnailWidget() : weak< WidgetDefinition_Record >;
	public import function FileThumbnailWidgetHandle() : WidgetDefinition_Record;
	public import function FileWidget() : weak< WidgetDefinition_Record >;
	public import function FileWidgetHandle() : WidgetDefinition_Record;
	public import function MainMenuButtonWidget() : weak< WidgetDefinition_Record >;
	public import function MainMenuButtonWidgetHandle() : WidgetDefinition_Record;
	public import function KeypadWidget() : weak< WidgetDefinition_Record >;
	public import function KeypadWidgetHandle() : WidgetDefinition_Record;
}

importonly class ComputerUIStyle_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataComputerUIStyle;
}

importonly class Cone_Record extends SenseShape_Record
{
	public import function Position2() : Vector3;
	public import function Position1() : Vector3;
	public import function Radius1() : Float;
	public import function Radius2() : Float;
}

importonly class ConstantStatModifier_Record extends StatModifier_Record
{
	public import function Value() : Float;
}

importonly class ConsumableBaseName_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function EnumComment() : CName;
	public import function Type() : gamedataConsumableBaseName;
}

importonly class ConsumableChargesPrereq_Record extends StatPoolPrereq_Record
{
}

importonly class ConsumableItem_Record extends Item_Record
{
	public import function ConsumableType() : weak< ConsumableType_Record >;
	public import function ConsumableTypeHandle() : ConsumableType_Record;
	public import function ConsumableBaseName() : weak< ConsumableBaseName_Record >;
	public import function ConsumableBaseNameHandle() : ConsumableBaseName_Record;
	public import function AtlasIcon() : CName;
	public import function CycleDuration() : Float;
	public import function CastPoint() : Float;
	public import function InitBlendDuration() : Float;
	public import function RemovePoint() : Float;
}

importonly class ConsumableType_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function EnumComment() : CName;
	public import function Type() : gamedataConsumableType;
}

importonly class ContainerType_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataContainerType;
}

importonly class ContentAssignment_Record extends TweakDBRecord
{
	public import function PowerLevelMod() : weak< StatModifier_Record >;
	public import function PowerLevelModHandle() : StatModifier_Record;
	public import function QuestType() : weak< NPCQuestAffiliation_Record >;
	public import function QuestTypeHandle() : NPCQuestAffiliation_Record;
}

importonly class ContinuousAttackEffector_Record extends ContinuousEffector_Record
{
	public import function AttackRecord() : weak< Attack_Record >;
	public import function AttackRecordHandle() : Attack_Record;
}

importonly class ContinuousEffector_Record extends Effector_Record
{
	public import function TimeDilationDriver() : weak< EffectorTimeDilationDriver_Record >;
	public import function TimeDilationDriverHandle() : EffectorTimeDilationDriver_Record;
	public import function DelayTime() : Float;
}

importonly class ControlledLootSet_Record extends TweakDBRecord
{
	public import function PlayerPrereqID() : weak< IPrereq_Record >;
	public import function PlayerPrereqIDHandle() : IPrereq_Record;
	public import function NpcPrereqID() : weak< IPrereq_Record >;
	public import function NpcPrereqIDHandle() : IPrereq_Record;
	public import function LootItems( out outList : array< weak< LootItem_Record > > );
	public import function GetLootItemsCount() : Int32;
	public import function GetLootItemsItem( index : Int32 ) : weak< LootItem_Record >;
	public import function GetLootItemsItemHandle( index : Int32 ) : LootItem_Record;
	public import function LootItemsContains( item : weak< LootItem_Record > ) : Bool;
	public import function ReplacementQueries( out outList : array< weak< ItemQueryElement_Record > > );
	public import function GetReplacementQueriesCount() : Int32;
	public import function GetReplacementQueriesItem( index : Int32 ) : weak< ItemQueryElement_Record >;
	public import function GetReplacementQueriesItemHandle( index : Int32 ) : ItemQueryElement_Record;
	public import function ReplacementQueriesContains( item : weak< ItemQueryElement_Record > ) : Bool;
	public import function ReplacementLootItems( out outList : array< weak< LootItem_Record > > );
	public import function GetReplacementLootItemsCount() : Int32;
	public import function GetReplacementLootItemsItem( index : Int32 ) : weak< LootItem_Record >;
	public import function GetReplacementLootItemsItemHandle( index : Int32 ) : LootItem_Record;
	public import function ReplacementLootItemsContains( item : weak< LootItem_Record > ) : Bool;
	public import function ExcludedContainerTypes( out outList : array< weak< ContainerType_Record > > );
	public import function GetExcludedContainerTypesCount() : Int32;
	public import function GetExcludedContainerTypesItem( index : Int32 ) : weak< ContainerType_Record >;
	public import function GetExcludedContainerTypesItemHandle( index : Int32 ) : ContainerType_Record;
	public import function ExcludedContainerTypesContains( item : weak< ContainerType_Record > ) : Bool;
	public import function ChanceIncreasePerAttempt() : Float;
	public import function MaxDrops() : Int32;
	public import function ChanceBase() : Float;
	public import function ProgressionBasedThreshold() : Float;
	public import function MaxDropsPerLevel() : Float;
	public import function ChanceMax() : Float;
	public import function ProgressionBasedChanceBonus() : Float;
	public import function BlocksFromNPCs() : Bool;
	public import function DropsInContainers() : Bool;
	public import function RollOverDropsPerLevel() : Bool;
	public import function MaxDropsGloballyShared() : Bool;
	public import function ItemsInSetShareDropCount() : Bool;
	public import function BlocksInContainers() : Bool;
	public import function DropsFromNPCs() : Bool;
}

importonly class ControlledLootTable_Record extends TweakDBRecord
{
	public import function ControlledLootSets( out outList : array< weak< ControlledLootSet_Record > > );
	public import function GetControlledLootSetsCount() : Int32;
	public import function GetControlledLootSetsItem( index : Int32 ) : weak< ControlledLootSet_Record >;
	public import function GetControlledLootSetsItemHandle( index : Int32 ) : ControlledLootSet_Record;
	public import function ControlledLootSetsContains( item : weak< ControlledLootSet_Record > ) : Bool;
	public import function MaxDropsPerAttempt() : Int32;
}

importonly class ConvertDamageToStatPoolEffector_Record extends Effector_Record
{
	public import function StatPoolType() : weak< StatPool_Record >;
	public import function StatPoolTypeHandle() : StatPool_Record;
	public import function OpSymbol() : CName;
	public import function Value() : Float;
}

importonly class Cooldown_Record extends TweakDBRecord
{
	public import function Type() : weak< CooldownType_Record >;
	public import function TypeHandle() : CooldownType_Record;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function Duration() : Float;
	public import function Modifiable() : Bool;
}

importonly class CooldownType_Record extends TweakDBRecord
{
	public import function Type() : CName;
}

importonly class CoverHealthCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function HpMultiplier() : Float;
}

importonly class CoverSelectionParameters_Record extends TweakDBRecord
{
	public import function ScoreOnlyForCombatTarget() : Bool;
	public import function VaidateOnlyForCombatTarget() : Bool;
}

importonly class CoverSelectionPreset_Record extends TweakDBRecord
{
	public import function CombatRing() : weak< AIRingType_Record >;
	public import function CombatRingHandle() : AIRingType_Record;
	public import function Scoring() : array< String >;
	public import function GetScoringCount() : Int32;
	public import function GetScoringItem( index : Int32 ) : String;
	public import function ScoringContains( item : String ) : Bool;
	public import function PostFiltering() : array< String >;
	public import function GetPostFilteringCount() : Int32;
	public import function GetPostFilteringItem( index : Int32 ) : String;
	public import function PostFilteringContains( item : String ) : Bool;
	public import function Filtering() : array< String >;
	public import function GetFilteringCount() : Int32;
	public import function GetFilteringItem( index : Int32 ) : String;
	public import function FilteringContains( item : String ) : Bool;
	public import function DismissedCoverTimer() : Float;
	public import function GatherRadius() : Float;
	public import function UsesLineOfSight() : Bool;
}

importonly class CoverTypeCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function MaxScore() : Float;
	public import function CoverScore() : Float;
	public import function ShootingSpotScore() : Float;
}

importonly class CrackAction_Record extends ItemAction_Record
{
	public import function Effector() : weak< Effector_Record >;
	public import function EffectorHandle() : Effector_Record;
}

importonly class Craftable_Record extends TweakDBRecord
{
	public import function CraftableItem( out outList : array< weak< Item_Record > > );
	public import function GetCraftableItemCount() : Int32;
	public import function GetCraftableItemItem( index : Int32 ) : weak< Item_Record >;
	public import function GetCraftableItemItemHandle( index : Int32 ) : Item_Record;
	public import function CraftableItemContains( item : weak< Item_Record > ) : Bool;
}

importonly class CraftingPackage_Record extends TweakDBRecord
{
	public import function CraftingRecipe( out outList : array< weak< RecipeElement_Record > > );
	public import function GetCraftingRecipeCount() : Int32;
	public import function GetCraftingRecipeItem( index : Int32 ) : weak< RecipeElement_Record >;
	public import function GetCraftingRecipeItemHandle( index : Int32 ) : RecipeElement_Record;
	public import function CraftingRecipeContains( item : weak< RecipeElement_Record > ) : Bool;
	public import function CraftingExpModifier() : Float;
	public import function OvercraftPenaltyModifier() : Float;
}

importonly class CraftingResult_Record extends TweakDBRecord
{
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
	public import function Amount() : Int32;
}

importonly class Crosshair_Record extends TweakDBRecord
{
	public import function WidgetResourcePath() : ResRef;
}

importonly class CrowdSettingsPackageBase_Record extends TweakDBRecord
{
	public import function Specs( out outList : array< weak< CrowdSlotMovementPatternBase_Record > > );
	public import function GetSpecsCount() : Int32;
	public import function GetSpecsItem( index : Int32 ) : weak< CrowdSlotMovementPatternBase_Record >;
	public import function GetSpecsItemHandle( index : Int32 ) : CrowdSlotMovementPatternBase_Record;
	public import function SpecsContains( item : weak< CrowdSlotMovementPatternBase_Record > ) : Bool;
}

importonly class CrowdSlotMovementPatternBase_Record extends TweakDBRecord
{
	public import function Settings() : weak< CrowdSlotMovementSettingsBase_Record >;
	public import function SettingsHandle() : CrowdSlotMovementSettingsBase_Record;
	public import function Name() : CName;
}

importonly class CrowdSlotMovementSettingsBase_Record extends TweakDBRecord
{
	public import function MaxStopSpeed() : Float;
	public import function DirectionSmoothFactor() : Float;
	public import function CurveFactor() : Float;
	public import function MinLightDelay() : Float;
	public import function RadiusSmoothFactor() : Float;
	public import function BumpTriggerSpeedFactor() : Float;
	public import function MaxSpeed() : Float;
	public import function AvoidanceReserve() : Float;
	public import function MaxDeviationFromPath() : Float;
	public import function SoftAdheranceMax() : Float;
	public import function MinAnimScale() : Float;
	public import function MoveSpeedType() : Int32;
	public import function OverlapTolerance() : Float;
	public import function MaxLightDelay() : Float;
	public import function Length() : Float;
	public import function StopReserve() : Float;
	public import function SoftAdheranceMin() : Float;
	public import function ReachFactor() : Float;
	public import function FenceGapReserve() : Float;
	public import function BumpTriggerMaxDistancePlayer() : Float;
	public import function MinSpeed() : Float;
	public import function BaseRadius() : Float;
	public import function AccelerationFactor() : Float;
	public import function BumpTriggerRadiusFactor() : Float;
	public import function RotationSpeed() : Float;
	public import function SurroundDistance() : Float;
	public import function BumpTriggerMaxDistanceNPC() : Float;
	public import function MaxSpeedTolerance() : Float;
	public import function RadiusTopClamp() : Float;
	public import function BumpTriggerMinSpeed() : Float;
	public import function BrakePressureFactor() : Float;
	public import function Acceleration() : Float;
	public import function RadiusBottomClamp() : Float;
	public import function AbsoluteFrontClamp() : Float;
	public import function MinStopSpeed() : Float;
	public import function LaneObstacleBuffer() : Float;
	public import function Deceleration() : Float;
	public import function CurveLimit() : Float;
	public import function MaxAnimScale() : Float;
	public import function SpeedStage() : Bool;
	public import function DirectionStage() : Bool;
	public import function PredictSpecialVehicles() : Bool;
	public import function DropItems() : Bool;
	public import function IgnoreLights() : Bool;
	public import function IgnorePlayer() : Bool;
	public import function IgnoreSpeedLimitations() : Bool;
	public import function IgnorePedestrians() : Bool;
	public import function IgnoreCars() : Bool;
	public import function IgnoreRules() : Bool;
	public import function IgnoreStatics() : Bool;
}

importonly class CurrencyReward_Record extends TweakDBRecord
{
	public import function Currency() : weak< Item_Record >;
	public import function CurrencyHandle() : Item_Record;
	public import function QuantityModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetQuantityModifiersCount() : Int32;
	public import function GetQuantityModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetQuantityModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function QuantityModifiersContains( item : weak< StatModifier_Record > ) : Bool;
}

importonly class CurrencyReward_inline0_Record extends ConstantStatModifier_Record
{
}

importonly class Curve_Record extends TweakDBRecord
{
	public import function CurveSetName() : CName;
	public import function CurveName() : CName;
}

importonly class CurveStatModifier_Record extends StatModifier_Record
{
	public import function Id() : String;
	public import function Column() : String;
	public import function RefStat() : weak< Stat_Record >;
	public import function RefStatHandle() : Stat_Record;
	public import function RefObject() : CName;
}

importonly class Curves_Record extends TweakDBRecord
{
	public import function Curves( out outList : array< weak< Curve_Record > > );
	public import function GetCurvesCount() : Int32;
	public import function GetCurvesItem( index : Int32 ) : weak< Curve_Record >;
	public import function GetCurvesItemHandle( index : Int32 ) : Curve_Record;
	public import function CurvesContains( item : weak< Curve_Record > ) : Bool;
}

importonly class CyberwareArea_Record extends EquipmentArea_Record
{
	public import function StatModifierGroups( out outList : array< weak< StatModifierGroup_Record > > );
	public import function GetStatModifierGroupsCount() : Int32;
	public import function GetStatModifierGroupsItem( index : Int32 ) : weak< StatModifierGroup_Record >;
	public import function GetStatModifierGroupsItemHandle( index : Int32 ) : StatModifierGroup_Record;
	public import function StatModifierGroupsContains( item : weak< StatModifierGroup_Record > ) : Bool;
}

importonly class DPadUIData_Record extends TweakDBRecord
{
	public import function RestrictionTags() : array< CName >;
	public import function GetRestrictionTagsCount() : Int32;
	public import function GetRestrictionTagsItem( index : Int32 ) : CName;
	public import function RestrictionTagsContains( item : CName ) : Bool;
}

importonly class DamageType_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function AssociatedStat() : weak< Stat_Record >;
	public import function AssociatedStatHandle() : Stat_Record;
	public import function Resistances( out outList : array< weak< StatDistributionData_Record > > );
	public import function GetResistancesCount() : Int32;
	public import function GetResistancesItem( index : Int32 ) : weak< StatDistributionData_Record >;
	public import function GetResistancesItemHandle( index : Int32 ) : StatDistributionData_Record;
	public import function ResistancesContains( item : weak< StatDistributionData_Record > ) : Bool;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function DamageType() : gamedataDamageType;
}

importonly class DefenseMode_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataDefenseMode;
}

importonly class DestructibleObject_Record extends BaseObject_Record
{
}

importonly class DetectionCurve_Record extends TweakDBRecord
{
	public import function States() : array< CName >;
	public import function GetStatesCount() : Int32;
	public import function GetStatesItem( index : Int32 ) : CName;
	public import function StatesContains( item : CName ) : Bool;
	public import function Name() : CName;
	public import function MaxDistance() : Float;
}

importonly class DevelopmentPoint_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataDevelopmentPointType;
}

importonly class Device_Record extends BaseObject_Record
{
	public import function RPGActions( out outList : array< weak< RPGAction_Record > > );
	public import function GetRPGActionsCount() : Int32;
	public import function GetRPGActionsItem( index : Int32 ) : weak< RPGAction_Record >;
	public import function GetRPGActionsItemHandle( index : Int32 ) : RPGAction_Record;
	public import function RPGActionsContains( item : weak< RPGAction_Record > ) : Bool;
	public import function AudioResourceName() : CName;
}

importonly class DeviceAreaAttack_Record extends Attack_GameEffect_Record
{
}

importonly class DeviceContentAssignment_Record extends ContentAssignment_Record
{
}

importonly class DeviceFX_Record extends TweakDBRecord
{
	public import function ScanGameEffectLength() : Float;
	public import function VisionConeEffectLength() : Float;
	public import function IdleEffectLength() : Float;
}

importonly class DeviceHackCategory_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function LocalizedDescription() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataDeviceHackCategory;
}

importonly class DeviceHackTier_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function LocalizedDescription() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataDeviceHackTier;
}

importonly class DeviceScreenType_Record extends TweakDBRecord
{
	public import function Ratio() : weak< WidgetRatio_Record >;
	public import function RatioHandle() : WidgetRatio_Record;
	public import function ContentRatio() : weak< WidgetRatio_Record >;
	public import function ContentRatioHandle() : WidgetRatio_Record;
	public import function LibraryPath() : ResRef;
}

importonly class DeviceUIDefinition_Record extends TweakDBRecord
{
	public import function ComputerScreenType() : weak< ComputerScreenType_Record >;
	public import function ComputerScreenTypeHandle() : ComputerScreenType_Record;
	public import function TerminalScreenType() : weak< TerminalScreenType_Record >;
	public import function TerminalScreenTypeHandle() : TerminalScreenType_Record;
}

importonly class DeviceWidgetDefinition_Record extends WidgetDefinition_Record
{
}

importonly class DisassemblingResult_Record extends TweakDBRecord
{
	public import function Ingredients( out outList : array< weak< RecipeElement_Record > > );
	public import function GetIngredientsCount() : Int32;
	public import function GetIngredientsItem( index : Int32 ) : weak< RecipeElement_Record >;
	public import function GetIngredientsItemHandle( index : Int32 ) : RecipeElement_Record;
	public import function IngredientsContains( item : weak< RecipeElement_Record > ) : Bool;
}

importonly class DistanceFromOthersCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function MinimalPreferredDistance() : Float;
	public import function MinimalDistance() : Float;
	public import function DistanceScoreMultiplier() : Float;
}

importonly class District_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function LocalizedName() : String;
	public import function EnumName() : String;
	public import function PreventionPreset() : weak< DistrictPreventionData_Record >;
	public import function PreventionPresetHandle() : DistrictPreventionData_Record;
	public import function ParentDistrict() : weak< District_Record >;
	public import function ParentDistrictHandle() : District_Record;
	public import function Gangs( out outList : array< weak< Affiliation_Record > > );
	public import function GetGangsCount() : Int32;
	public import function GetGangsItem( index : Int32 ) : weak< Affiliation_Record >;
	public import function GetGangsItemHandle( index : Int32 ) : Affiliation_Record;
	public import function GangsContains( item : weak< Affiliation_Record > ) : Bool;
	public import function UiIcon() : CName;
	public import function UiState() : CName;
	public import function PoliceRadioSceneEntryPoint() : CName;
	public import function GunShotStimRange() : Float;
	public import function CrimeMultiplier() : Float;
	public import function ExplosiveDeviceStimRangeMultiplier() : Float;
	public import function IsQuestDistrict() : Bool;
	public import function Type() : gamedataDistrict;
}

importonly class DistrictPrereq_Record extends IPrereq_Record
{
	public import function District() : weak< District_Record >;
	public import function DistrictHandle() : District_Record;
}

importonly class DistrictPreventionData_Record extends TweakDBRecord
{
	public import function Heat3() : weak< PreventionHeatData_Record >;
	public import function Heat3Handle() : PreventionHeatData_Record;
	public import function Heat5() : weak< PreventionHeatData_Record >;
	public import function Heat5Handle() : PreventionHeatData_Record;
	public import function Heat1() : weak< PreventionHeatData_Record >;
	public import function Heat1Handle() : PreventionHeatData_Record;
	public import function Heat2() : weak< PreventionHeatData_Record >;
	public import function Heat2Handle() : PreventionHeatData_Record;
	public import function Heat4() : weak< PreventionHeatData_Record >;
	public import function Heat4Handle() : PreventionHeatData_Record;
	public import function Recon() : weak< PreventionHeatData_Record >;
	public import function ReconHandle() : PreventionHeatData_Record;
	public import function InputLockTime() : Float;
	public import function InputLockOverrideThreshold() : Int32;
	public import function SpawnOriginMaxDistance() : Float;
}

importonly class DriveHelper_Record extends TweakDBRecord
{
	public import function Type() : weak< DriveHelperType_Record >;
	public import function TypeHandle() : DriveHelperType_Record;
}

importonly class DriveHelperType_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
}

importonly class DriveWheelsAccelerateNoise_Record extends DriveHelper_Record
{
	public import function AccelerationBoost() : Float;
	public import function MinForcesDifference() : Float;
	public import function MaxForcesDifference() : Float;
	public import function AccelerationBoostReverse() : Float;
	public import function AccelerationBoostMaxSpeed() : Float;
	public import function MinApplyTime() : Float;
	public import function MaxApplyTime() : Float;
	public import function AccelerationNoiseMaxSpeed() : Float;
}

importonly class DriverCombatType_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataDriverCombatType;
}

importonly class DroneAnimationSetup_Record extends TweakDBRecord
{
	public import function TiltAngleOnSpeed() : Float;
	public import function SizeFront() : Float;
	public import function SizeBack() : Float;
	public import function WalkTiltCoefficient() : Float;
	public import function SizeLeft() : Float;
	public import function SizeRight() : Float;
	public import function Mass() : Float;
	public import function SpeedIdleThreshold() : Float;
	public import function MassNormalizedCoefficient() : Float;
	public import function StartingRecoveryBalance() : Float;
	public import function PseudoAcceleration() : Float;
	public import function TurnInertiaDamping() : Float;
}

importonly class DynamicDownforceHelper_Record extends DriveHelper_Record
{
	public import function MaxSpeed() : Float;
	public import function MaxSpeedFactorGround() : Float;
	public import function MinSpeed() : Float;
	public import function MaxSpeedFactorAir() : Float;
}

importonly class DynamicVehicleData_Record extends TweakDBRecord
{
	public import function VehicleRecord() : weak< Vehicle_Record >;
	public import function VehicleRecordHandle() : Vehicle_Record;
	public import function UnitRecordsPool( out outList : array< weak< WeightedCharacter_Record > > );
	public import function GetUnitRecordsPoolCount() : Int32;
	public import function GetUnitRecordsPoolItem( index : Int32 ) : weak< WeightedCharacter_Record >;
	public import function GetUnitRecordsPoolItemHandle( index : Int32 ) : WeightedCharacter_Record;
	public import function UnitRecordsPoolContains( item : weak< WeightedCharacter_Record > ) : Bool;
}

importonly class Effector_Record extends TweakDBRecord
{
	public import function PrereqRecord() : weak< IPrereq_Record >;
	public import function PrereqRecordHandle() : IPrereq_Record;
	public import function StatModifierGroups( out outList : array< weak< StatModifierGroup_Record > > );
	public import function GetStatModifierGroupsCount() : Int32;
	public import function GetStatModifierGroupsItem( index : Int32 ) : weak< StatModifierGroup_Record >;
	public import function GetStatModifierGroupsItemHandle( index : Int32 ) : StatModifierGroup_Record;
	public import function StatModifierGroupsContains( item : weak< StatModifierGroup_Record > ) : Bool;
	public import function EffectorClassName() : CName;
	public import function RemoveAfterPrereqCheck() : Bool;
	public import function RemoveAfterActionCall() : Bool;
}

importonly class EffectorTimeDilationDriver_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataEffectorTimeDilationDriver;
}

importonly class EnvLight_Record extends TweakDBRecord
{
	public import function Color() : array< Int32 >;
	public import function GetColorCount() : Int32;
	public import function GetColorItem( index : Int32 ) : Int32;
	public import function ColorContains( item : Int32 ) : Bool;
	public import function Intensity() : Float;
	public import function Radius() : Float;
	public import function Temperature() : Float;
}

importonly class EquipSlot_Record extends TweakDBRecord
{
	public import function UnlockPrereqRecord() : weak< IPrereq_Record >;
	public import function UnlockPrereqRecordHandle() : IPrereq_Record;
	public import function OnInsertion( out outList : array< weak< GameplayLogicPackage_Record > > );
	public import function GetOnInsertionCount() : Int32;
	public import function GetOnInsertionItem( index : Int32 ) : weak< GameplayLogicPackage_Record >;
	public import function GetOnInsertionItemHandle( index : Int32 ) : GameplayLogicPackage_Record;
	public import function OnInsertionContains( item : weak< GameplayLogicPackage_Record > ) : Bool;
	public import function VisibleWhenLocked() : Bool;
}

importonly class EquipmentArea_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function LocalizedName() : String;
	public import function EquipSlots( out outList : array< weak< EquipSlot_Record > > );
	public import function GetEquipSlotsCount() : Int32;
	public import function GetEquipSlotsItem( index : Int32 ) : weak< EquipSlot_Record >;
	public import function GetEquipSlotsItemHandle( index : Int32 ) : EquipSlot_Record;
	public import function EquipSlotsContains( item : weak< EquipSlot_Record > ) : Bool;
	public import function EnumName() : CName;
	public import function Type() : gamedataEquipmentArea;
}

importonly class EquipmentMovementSound_Record extends TweakDBRecord
{
	public import function AudioMovementName() : CName;
	public import function Priority() : Float;
}

importonly class EthnicNames_Record extends TweakDBRecord
{
	public import function Gender() : weak< Gender_Record >;
	public import function GenderHandle() : Gender_Record;
	public import function Ethnicity() : weak< Ethnicity_Record >;
	public import function EthnicityHandle() : Ethnicity_Record;
	public import function Surnames() : array< CName >;
	public import function GetSurnamesCount() : Int32;
	public import function GetSurnamesItem( index : Int32 ) : CName;
	public import function SurnamesContains( item : CName ) : Bool;
	public import function VisualTags() : array< CName >;
	public import function GetVisualTagsCount() : Int32;
	public import function GetVisualTagsItem( index : Int32 ) : CName;
	public import function VisualTagsContains( item : CName ) : Bool;
	public import function Names() : array< CName >;
	public import function GetNamesCount() : Int32;
	public import function GetNamesItem( index : Int32 ) : CName;
	public import function NamesContains( item : CName ) : Bool;
	public import function NameOrderFormat() : CName;
	public import function DisplayName() : CName;
}

importonly class Ethnicity_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataEthnicity;
}

importonly class FacialPreset_Record extends TweakDBRecord
{
	public import function ProfileName() : CName;
	public import function UpperFaceBlendAdditive() : Bool;
	public import function LowerFaceBlendAdditive() : Bool;
	public import function EyesBlendAdditive() : Bool;
}

importonly class FastTravelBinkData_Record extends TweakDBRecord
{
	public import function District() : weak< District_Record >;
	public import function DistrictHandle() : District_Record;
	public import function Time() : weak< Time_Record >;
	public import function TimeHandle() : Time_Record;
	public import function Weather() : weak< Weather_Record >;
	public import function WeatherHandle() : Weather_Record;
	public import function BinkPath() : ResRef;
}

importonly class FastTravelBinksGroup_Record extends TweakDBRecord
{
	public import function BinksData( out outList : array< weak< FastTravelBinkData_Record > > );
	public import function GetBinksDataCount() : Int32;
	public import function GetBinksDataItem( index : Int32 ) : weak< FastTravelBinkData_Record >;
	public import function GetBinksDataItemHandle( index : Int32 ) : FastTravelBinkData_Record;
	public import function BinksDataContains( item : weak< FastTravelBinkData_Record > ) : Bool;
}

importonly class FastTravelPoint_Record extends TweakDBRecord
{
	public import function Description() : String;
	public import function DisplayName() : String;
	public import function District() : weak< District_Record >;
	public import function DistrictHandle() : District_Record;
	public import function ShowOnWorldMap() : Bool;
	public import function ShowInWorld() : Bool;
	public import function SubwayStation() : Bool;
}

importonly class FastTravelScreenData_Record extends TweakDBRecord
{
	public import function Time() : weak< Time_Record >;
	public import function TimeHandle() : Time_Record;
	public import function District() : weak< District_Record >;
	public import function DistrictHandle() : District_Record;
	public import function Weather() : weak< Weather_Record >;
	public import function WeatherHandle() : Weather_Record;
	public import function ExtendingResourcePath() : ResRef;
	public import function ResourcePath() : ResRef;
	public import function IsBase() : Bool;
}

importonly class FastTravelScreenDataGroup_Record extends TweakDBRecord
{
	public import function ScreensData( out outList : array< weak< FastTravelScreenData_Record > > );
	public import function GetScreensDataCount() : Int32;
	public import function GetScreensDataItem( index : Int32 ) : weak< FastTravelScreenData_Record >;
	public import function GetScreensDataItemHandle( index : Int32 ) : FastTravelScreenData_Record;
	public import function ScreensDataContains( item : weak< FastTravelScreenData_Record > ) : Bool;
}

importonly class FastTravelSystem_Record extends TweakDBRecord
{
	public import function FastTravelPointsTotal() : Int32;
}

importonly class FocusClue_Record extends ScannableData_Record
{
}

importonly class Footstep_Record extends TweakDBRecord
{
	public import function FootstepEntityLeft() : CName;
	public import function FootstepEntityRight() : CName;
	public import function TimeToFade() : Float;
}

importonly class ForceDismembermentEffector_Record extends Effector_Record
{
	public import function WoundType() : String;
	public import function BodyPart() : String;
	public import function DismembermentChance() : Float;
	public import function ShouldKillNPC() : Bool;
	public import function SkipDeathAnim() : Bool;
	public import function IsCritical() : Bool;
}

importonly class FriendlyTargetAngleDistanceCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function CoverProtectionAngleMul() : Float;
	public import function MinDot() : Float;
	public import function AngleDistanceScore() : Float;
	public import function PositionChangeThreshold() : Float;
	public import function MaxScoreIfInRange() : Bool;
}

importonly class FriendlyTargetDistanceCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function SpatialHintMults() : Vector3;
	public import function FriendlyTargetPreferredDistance() : Float;
	public import function FriendlyTargetMaxDistance() : Float;
	public import function FriendlyTargetZLimit() : Float;
	public import function FriendlyTargetMinDistance() : Float;
	public import function DistanceToFriendlyTargetMultiplier() : Float;
}

importonly class FxAction_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataFxAction;
}

importonly class FxActionType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataFxActionType;
}

importonly class GOGReward_Record extends TweakDBRecord
{
	public import function IconsAtlasSlot() : CName;
	public import function Description() : CName;
	public import function DisplayName() : CName;
	public import function Group() : CName;
	public import function SlotType() : CName;
	public import function RewardToken() : Int32;
}

importonly class Gadget_Record extends WeaponItem_Record
{
}

importonly class GameplayAbility_Record extends TweakDBRecord
{
	public import function AbilityPackage() : weak< GameplayLogicPackage_Record >;
	public import function AbilityPackageHandle() : GameplayLogicPackage_Record;
	public import function PrereqsForUse( out outList : array< weak< IPrereq_Record > > );
	public import function GetPrereqsForUseCount() : Int32;
	public import function GetPrereqsForUseItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetPrereqsForUseItemHandle( index : Int32 ) : IPrereq_Record;
	public import function PrereqsForUseContains( item : weak< IPrereq_Record > ) : Bool;
	public import function PrereqsForUIValidation( out outList : array< weak< IPrereq_Record > > );
	public import function GetPrereqsForUIValidationCount() : Int32;
	public import function GetPrereqsForUIValidationItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetPrereqsForUIValidationItemHandle( index : Int32 ) : IPrereq_Record;
	public import function PrereqsForUIValidationContains( item : weak< IPrereq_Record > ) : Bool;
	public import function Loc_key_name() : CName;
	public import function Loc_key_desc() : CName;
	public import function ShowInCodex() : Bool;
}

importonly class GameplayAbilityGroup_Record extends TweakDBRecord
{
	public import function Abilities( out outList : array< weak< GameplayAbility_Record > > );
	public import function GetAbilitiesCount() : Int32;
	public import function GetAbilitiesItem( index : Int32 ) : weak< GameplayAbility_Record >;
	public import function GetAbilitiesItemHandle( index : Int32 ) : GameplayAbility_Record;
	public import function AbilitiesContains( item : weak< GameplayAbility_Record > ) : Bool;
}

importonly class GameplayLogicPackage_Record extends TweakDBRecord
{
	public import function UIData() : weak< GameplayLogicPackageUIData_Record >;
	public import function UIDataHandle() : GameplayLogicPackageUIData_Record;
	public import function StatPools( out outList : array< weak< StatPool_Record > > );
	public import function GetStatPoolsCount() : Int32;
	public import function GetStatPoolsItem( index : Int32 ) : weak< StatPool_Record >;
	public import function GetStatPoolsItemHandle( index : Int32 ) : StatPool_Record;
	public import function StatPoolsContains( item : weak< StatPool_Record > ) : Bool;
	public import function Effectors( out outList : array< weak< Effector_Record > > );
	public import function GetEffectorsCount() : Int32;
	public import function GetEffectorsItem( index : Int32 ) : weak< Effector_Record >;
	public import function GetEffectorsItemHandle( index : Int32 ) : Effector_Record;
	public import function EffectorsContains( item : weak< Effector_Record > ) : Bool;
	public import function Stats( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatsCount() : Int32;
	public import function GetStatsItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatsItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatsContains( item : weak< StatModifier_Record > ) : Bool;
	public import function Items( out outList : array< weak< InventoryItem_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< InventoryItem_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : InventoryItem_Record;
	public import function ItemsContains( item : weak< InventoryItem_Record > ) : Bool;
	public import function AnimationWrapperOverrides() : array< CName >;
	public import function GetAnimationWrapperOverridesCount() : Int32;
	public import function GetAnimationWrapperOverridesItem( index : Int32 ) : CName;
	public import function AnimationWrapperOverridesContains( item : CName ) : Bool;
	public import function Prereq() : CName;
	public import function Stackable() : Bool;
}

importonly class GameplayLogicPackageUIData_Record extends TweakDBRecord
{
	public import function LocalizedDescription() : String;
	public import function LocalizedName() : String;
	public import function FloatValues() : array< Float >;
	public import function GetFloatValuesCount() : Int32;
	public import function GetFloatValuesItem( index : Int32 ) : Float;
	public import function FloatValuesContains( item : Float ) : Bool;
	public import function IntValues() : array< Int32 >;
	public import function GetIntValuesCount() : Int32;
	public import function GetIntValuesItem( index : Int32 ) : Int32;
	public import function IntValuesContains( item : Int32 ) : Bool;
	public import function NameValues() : array< CName >;
	public import function GetNameValuesCount() : Int32;
	public import function GetNameValuesItem( index : Int32 ) : CName;
	public import function NameValuesContains( item : CName ) : Bool;
	public import function Stats( out outList : array< weak< Stat_Record > > );
	public import function GetStatsCount() : Int32;
	public import function GetStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function StatsContains( item : weak< Stat_Record > ) : Bool;
	public import function IconPath() : CName;
}

importonly class GameplayRestrictionStatusEffect_Record extends StatusEffect_Record
{
	public import function ActionRestriction() : weak< ActionRestrictionGroup_Record >;
	public import function ActionRestrictionHandle() : ActionRestrictionGroup_Record;
}

importonly class GameplayTagsPrereq_Record extends IPrereq_Record
{
	public import function AllowedTags() : array< CName >;
	public import function GetAllowedTagsCount() : Int32;
	public import function GetAllowedTagsItem( index : Int32 ) : CName;
	public import function AllowedTagsContains( item : CName ) : Bool;
	public import function Invert() : Bool;
}

importonly class Gender_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataGender;
}

importonly class GenderEntity_Record extends TweakDBRecord
{
	public import function Gender() : weak< Gender_Record >;
	public import function GenderHandle() : Gender_Record;
	public import function MultiplayerEntities() : array< ResRef >;
	public import function GetMultiplayerEntitiesCount() : Int32;
	public import function GetMultiplayerEntitiesItem( index : Int32 ) : ResRef;
	public import function Entity() : ResRef;
	public import function Initial() : Bool;
}

importonly class GenericHighwaySign_Record extends BaseSign_Record
{
	public import function DistrictName() : String;
	public import function SubDistrictName() : String;
	public import function IconName() : CName;
}

importonly class GenericMetroSign_Record extends BaseSign_Record
{
	public import function SubDistrictName() : String;
	public import function StationName() : String;
	public import function MetroLineName() : array< CName >;
	public import function GetMetroLineNameCount() : Int32;
	public import function GetMetroLineNameItem( index : Int32 ) : CName;
	public import function MetroLineNameContains( item : CName ) : Bool;
	public import function IconName() : CName;
}

importonly class GenericStreetNameSign_Record extends BaseSign_Record
{
	public import function DistrictName() : String;
	public import function SubDistrictName() : String;
	public import function StreetName() : String;
}

importonly class Grenade_Record extends Gadget_Record
{
	public import function DetonationSound() : String;
	public import function DetonationRumbleName() : String;
	public import function UnderwaterDetonationRumbleName() : String;
	public import function DeepWaterAttack() : weak< Attack_Record >;
	public import function DeepWaterAttackHandle() : Attack_Record;
	public import function Attack() : weak< Attack_Record >;
	public import function AttackHandle() : Attack_Record;
	public import function ShallowWaterAttack() : weak< Attack_Record >;
	public import function ShallowWaterAttackHandle() : Attack_Record;
	public import function EnhancedPerkAttack() : weak< Attack_Record >;
	public import function EnhancedPerkAttackHandle() : Attack_Record;
	public import function NpcHitReactionAttack() : weak< Attack_Record >;
	public import function NpcHitReactionAttackHandle() : Attack_Record;
	public import function DeliveryMethod() : weak< GrenadeDeliveryMethod_Record >;
	public import function DeliveryMethodHandle() : GrenadeDeliveryMethod_Record;
	public import function DetonationStimType() : weak< StimType_Record >;
	public import function DetonationStimTypeHandle() : StimType_Record;
	public import function EnemyAttack() : weak< Attack_Record >;
	public import function EnemyAttackHandle() : Attack_Record;
	public import function AdditionalAttack() : weak< Attack_Record >;
	public import function AdditionalAttackHandle() : Attack_Record;
	public import function RotationAxesSpeeds() : array< Float >;
	public import function GetRotationAxesSpeedsCount() : Int32;
	public import function GetRotationAxesSpeedsItem( index : Int32 ) : Float;
	public import function RotationAxesSpeedsContains( item : Float ) : Bool;
	public import function RotationAxesZ() : array< Float >;
	public import function GetRotationAxesZCount() : Int32;
	public import function GetRotationAxesZItem( index : Int32 ) : Float;
	public import function RotationAxesZContains( item : Float ) : Bool;
	public import function RotationAxesX() : array< Float >;
	public import function GetRotationAxesXCount() : Int32;
	public import function GetRotationAxesXItem( index : Int32 ) : Float;
	public import function RotationAxesXContains( item : Float ) : Bool;
	public import function RotationAxesY() : array< Float >;
	public import function GetRotationAxesYCount() : Int32;
	public import function GetRotationAxesYItem( index : Int32 ) : Float;
	public import function RotationAxesYContains( item : Float ) : Bool;
	public import function AttackDuration() : Float;
	public import function ShallowWaterDepth() : Float;
	public import function StoryDifficultySelfDamagePerTick() : Float;
	public import function HardDifficultySelfDamagePerTick() : Float;
	public import function EnhancedAttackDurationFromPerk() : Float;
	public import function AttackRadius() : Float;
	public import function RotationSpeedMax() : Float;
	public import function EnhancedAttackRadiusFromPerk() : Float;
	public import function NormalDifficultySelfDamagePerTick() : Float;
	public import function Npc_hardDifficultySelfDamagePerTick() : Float;
	public import function UnderwaterDetonationStimRadius() : Float;
	public import function SinkingDetonationDelay() : Float;
	public import function SinkingDepth() : Float;
	public import function RandomRotationAxes() : Int32;
	public import function RotationSpeedMin() : Float;
	public import function DetonationStimRadius() : Float;
	public import function Npc_veryHardDifficultySelfDamagePerTick() : Float;
	public import function WaterDetonationImpulseStrength() : Float;
	public import function DeepWaterDepth() : Float;
	public import function Seed() : Int32;
	public import function WaterDetonationImpulseRadiusCoef() : Float;
	public import function WaterSurfaceImpactImpulseStrength() : Float;
	public import function Npc_storyDifficultySelfDamagePerTick() : Float;
	public import function VeryHardDifficultySelfDamagePerTick() : Float;
	public import function Npc_normalDifficultySelfDamagePerTick() : Float;
	public import function ShootCollisionEnableDelay() : Float;
	public import function WaterSurfaceImpactImpulseRadius() : Float;
	public import function RemoveMeshOnDetonation() : Bool;
	public import function SpawnFxAtWaterSurface() : Bool;
	public import function ReleaseOnDetonation() : Bool;
	public import function UseSeed() : Bool;
}

importonly class GrenadeDeliveryMethod_Record extends TweakDBRecord
{
	public import function Type() : weak< GrenadeDeliveryMethodType_Record >;
	public import function TypeHandle() : GrenadeDeliveryMethodType_Record;
	public import function Bounciness() : Float;
	public import function DetonationTimer() : Float;
	public import function TrackingRadius() : Float;
	public import function InitialVelocity() : Float;
	public import function InitialQuickThrowVelocity() : Float;
	public import function AccelerationZ() : Float;
}

importonly class GrenadeDeliveryMethodType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataGrenadeDeliveryMethodType;
}

importonly class HUD_Preset_Entry_Record extends TweakDBRecord
{
	public import function HudEntries() : array< CName >;
	public import function GetHudEntriesCount() : Int32;
	public import function GetHudEntriesItem( index : Int32 ) : CName;
	public import function HudEntriesContains( item : CName ) : Bool;
}

importonly class HackCategory_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function LocalizedDescription() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataHackCategory;
}

importonly class HackingMiniGame_Record extends TweakDBRecord
{
	public import function AllowedTraps( out outList : array< weak< Trap_Record > > );
	public import function GetAllowedTrapsCount() : Int32;
	public import function GetAllowedTrapsItem( index : Int32 ) : weak< Trap_Record >;
	public import function GetAllowedTrapsItemHandle( index : Int32 ) : Trap_Record;
	public import function AllowedTrapsContains( item : weak< Trap_Record > ) : Bool;
	public import function PredefinedNetworkPrograms() : array< String >;
	public import function GetPredefinedNetworkProgramsCount() : Int32;
	public import function GetPredefinedNetworkProgramsItem( index : Int32 ) : String;
	public import function PredefinedNetworkProgramsContains( item : String ) : Bool;
	public import function PredefinedBasicAccess() : array< String >;
	public import function GetPredefinedBasicAccessCount() : Int32;
	public import function GetPredefinedBasicAccessItem( index : Int32 ) : String;
	public import function PredefinedBasicAccessContains( item : String ) : Bool;
	public import function PredefinedEnemyPrograms() : array< String >;
	public import function GetPredefinedEnemyProgramsCount() : Int32;
	public import function GetPredefinedEnemyProgramsItem( index : Int32 ) : String;
	public import function PredefinedEnemyProgramsContains( item : String ) : Bool;
	public import function Symbols() : array< String >;
	public import function GetSymbolsCount() : Int32;
	public import function GetSymbolsItem( index : Int32 ) : String;
	public import function SymbolsContains( item : String ) : Bool;
	public import function PredefinedGrid() : array< String >;
	public import function GetPredefinedGridCount() : Int32;
	public import function GetPredefinedGridItem( index : Int32 ) : String;
	public import function PredefinedGridContains( item : String ) : Bool;
	public import function PredefinedCyberdeckPrograms() : array< String >;
	public import function GetPredefinedCyberdeckProgramsCount() : Int32;
	public import function GetPredefinedCyberdeckProgramsItem( index : Int32 ) : String;
	public import function PredefinedCyberdeckProgramsContains( item : String ) : Bool;
	public import function SymbolProbabilities() : array< String >;
	public import function GetSymbolProbabilitiesCount() : Int32;
	public import function GetSymbolProbabilitiesItem( index : Int32 ) : String;
	public import function SymbolProbabilitiesContains( item : String ) : Bool;
	public import function SymbolProbabilitiesAlternative() : array< String >;
	public import function GetSymbolProbabilitiesAlternativeCount() : Int32;
	public import function GetSymbolProbabilitiesAlternativeItem( index : Int32 ) : String;
	public import function SymbolProbabilitiesAlternativeContains( item : String ) : Bool;
	public import function NetworkLevel() : Int32;
	public import function EnemyNetrunnerLevel() : Int32;
	public import function Dimension() : Int32;
	public import function GameType() : Int32;
	public import function InitialTimer() : Int32;
	public import function BufferModifier() : Int32;
	public import function HiddenCellsProbability() : Int32;
	public import function HasEnemyNetrunner() : Bool;
	public import function HasHiddenCells() : Bool;
	public import function HasInitialTimer() : Bool;
	public import function Officer() : Bool;
}

importonly class HandbrakeFrictionModifier_Record extends DriveHelper_Record
{
	public import function BlendOutTime() : Float;
	public import function RearWheelsLongFrictionCoef() : Float;
	public import function RearWheelsLatFrictionCoef() : Float;
	public import function AdditionalBrakeForLongUse() : Float;
	public import function PostHandbrakeTractionBoost() : Float;
}

importonly class HandicapLootList_Record extends TweakDBRecord
{
	public import function Loot( out outList : array< weak< HandicapLootPreset_Record > > );
	public import function GetLootCount() : Int32;
	public import function GetLootItem( index : Int32 ) : weak< HandicapLootPreset_Record >;
	public import function GetLootItemHandle( index : Int32 ) : HandicapLootPreset_Record;
	public import function LootContains( item : weak< HandicapLootPreset_Record > ) : Bool;
}

importonly class HandicapLootPreset_Record extends TweakDBRecord
{
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
	public import function HandicapLimit() : Int32;
	public import function HandicapMinQty() : Int32;
	public import function HandicapMaxQty() : Int32;
}

importonly class HitPrereq_Record extends IPrereq_Record
{
	public import function CallbackType() : String;
	public import function PipelineType() : String;
	public import function PipelineStage() : String;
	public import function Conditions( out outList : array< weak< HitPrereqCondition_Record > > );
	public import function GetConditionsCount() : Int32;
	public import function GetConditionsItem( index : Int32 ) : weak< HitPrereqCondition_Record >;
	public import function GetConditionsItemHandle( index : Int32 ) : HitPrereqCondition_Record;
	public import function ConditionsContains( item : weak< HitPrereqCondition_Record > ) : Bool;
	public import function IsSynchronous() : Bool;
	public import function IgnoreSelfInflictedPressureWave() : Bool;
}

importonly class HitPrereqCondition_Record extends TweakDBRecord
{
	public import function Type() : weak< HitPrereqConditionType_Record >;
	public import function TypeHandle() : HitPrereqConditionType_Record;
	public import function Invert() : Bool;
	public import function OnlyOncePerShot() : Bool;
}

importonly class HitPrereqConditionType_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function EnumComment() : CName;
	public import function Type() : gamedataHitPrereqConditionType;
}

importonly class HomingGDM_Record extends GrenadeDeliveryMethod_Record
{
	public import function FlyUpParameters() : weak< AccelerateTowardsParameters_Record >;
	public import function FlyUpParametersHandle() : AccelerateTowardsParameters_Record;
	public import function FlyToTargetParameters() : weak< AccelerateTowardsParameters_Record >;
	public import function FlyToTargetParametersHandle() : AccelerateTowardsParameters_Record;
	public import function FreezeDelay() : Float;
	public import function FreezeDuration() : Float;
	public import function LockOnDelay() : Float;
	public import function FreezeDelayAfterBounce() : Float;
	public import function LockOnFailDetonationDelay() : Float;
	public import function LockOnAltitude() : Float;
}

importonly class HomingParameters_Record extends TweakDBRecord
{
	public import function AngleInVerticalPlane() : Float;
	public import function HalfLeanAngle() : Float;
	public import function AngleInHitPlane() : Float;
	public import function EndLeanAngle() : Float;
	public import function BendFactor() : Float;
	public import function ReturnTimeMargin() : Float;
	public import function BendTimeRatio() : Float;
	public import function InterpolationTimeRatio() : Float;
	public import function StartVelocity() : Float;
	public import function LinearTimeRatio() : Float;
	public import function SnapRadius() : Float;
	public import function AngleInterpolationDuration() : Float;
	public import function Accuracy() : Float;
	public import function ShouldRotate() : Bool;
}

importonly class HudEnhancer_Record extends TweakDBRecord
{
	public import function Distance() : Float;
}

importonly class IPrereq_Record extends TweakDBRecord
{
	public import function PrereqClassName() : CName;
}

importonly class IconsGeneratorContext_Record extends TweakDBRecord
{
	public import function MalePlayerAnimSet() : ResRef;
	public import function FemalePlayerAnimSet() : ResRef;
}

importonly class ImprovementRelation_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataImprovementRelation;
}

importonly class InAirGravityModifier_Record extends DriveHelper_Record
{
	public import function SmoothingFactor() : Float;
	public import function BaseAddedGravity() : Float;
	public import function MinDriveSpeed() : Float;
	public import function MaxDriveSpeed() : Float;
	public import function DriveSpeedAddedGravity() : Float;
	public import function ZVelReductionStart() : Float;
	public import function ZVelReductionEnd() : Float;
}

importonly class InitLoadingScreen_Record extends TweakDBRecord
{
	public import function MainMenuResource() : ResRef;
	public import function MainMenuLoopAnimName() : CName;
	public import function LoopAnimName() : CName;
	public import function FirstAnimLibraryName() : CName;
	public import function LoadingScreenResource() : ResRef;
	public import function VoTrackAnimName() : CName;
	public import function ThirdAnimName() : CName;
	public import function FirstAnimName() : CName;
	public import function SecondAnimName() : CName;
	public import function SecondAnimLibraryName() : CName;
	public import function ThirdAnimLibraryName() : CName;
	public import function MainMenuAnimName() : CName;
	public import function MainMenuLibraryName() : CName;
	public import function IsBase() : Bool;
}

importonly class InteractionBase_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Action() : String;
	public import function PrereqID() : String;
	public import function CaptionIcon() : weak< ChoiceCaptionIconPart_Record >;
	public import function CaptionIconHandle() : ChoiceCaptionIconPart_Record;
	public import function Caption() : CName;
	public import function Description() : CName;
}

importonly class InteractionMountBase_Record extends InteractionBase_Record
{
	public import function VehicleMountSlot() : CName;
	public import function Tag() : CName;
}

importonly class InventoryItem_Record extends TweakDBRecord
{
	public import function EquipSlot_DEPRECATED() : weak< AttachmentSlot_Record >;
	public import function EquipSlot_DEPRECATEDHandle() : AttachmentSlot_Record;
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
	public import function ActiveForSlot() : weak< AttachmentSlot_Record >;
	public import function ActiveForSlotHandle() : AttachmentSlot_Record;
	public import function Quantity() : Int32;
	public import function ChanceInCrowd() : Float;
}

importonly class InventoryItemGroup_Record extends TweakDBRecord
{
	public import function Items( out outList : array< weak< InventoryItem_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< InventoryItem_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : InventoryItem_Record;
	public import function ItemsContains( item : weak< InventoryItem_Record > ) : Bool;
}

importonly class InventoryItemSet_Record extends TweakDBRecord
{
	public import function Items( out outList : array< weak< InventoryItem_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< InventoryItem_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : InventoryItem_Record;
	public import function ItemsContains( item : weak< InventoryItem_Record > ) : Bool;
}

importonly class IsHackable_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataIsHackable;
}

importonly class Item_Record extends BaseObject_Record
{
	public import function FriendlyName() : String;
	public import function IconPath() : String;
	public import function LocalizedName() : String;
	public import function MovementSound() : weak< EquipmentMovementSound_Record >;
	public import function MovementSoundHandle() : EquipmentMovementSound_Record;
	public import function Crosshair() : weak< Crosshair_Record >;
	public import function CrosshairHandle() : Crosshair_Record;
	public import function EquipArea() : weak< EquipmentArea_Record >;
	public import function EquipAreaHandle() : EquipmentArea_Record;
	public import function CraftingData() : weak< CraftingPackage_Record >;
	public import function CraftingDataHandle() : CraftingPackage_Record;
	public import function ItemType() : weak< ItemType_Record >;
	public import function ItemTypeHandle() : ItemType_Record;
	public import function Blueprint() : weak< ItemBlueprint_Record >;
	public import function BlueprintHandle() : ItemBlueprint_Record;
	public import function NpcRPGData() : weak< RPGDataPackage_Record >;
	public import function NpcRPGDataHandle() : RPGDataPackage_Record;
	public import function Quality() : weak< Quality_Record >;
	public import function QualityHandle() : Quality_Record;
	public import function ParentAttachmentType() : weak< ParentAttachmentType_Record >;
	public import function ParentAttachmentTypeHandle() : ParentAttachmentType_Record;
	public import function ItemStructure() : weak< ItemStructure_Record >;
	public import function ItemStructureHandle() : ItemStructure_Record;
	public import function Equivalent() : weak< Item_Record >;
	public import function EquivalentHandle() : Item_Record;
	public import function ItemCategory() : weak< ItemCategory_Record >;
	public import function ItemCategoryHandle() : ItemCategory_Record;
	public import function CpoItemCategory() : weak< CPOItemCategoryBase_Record >;
	public import function CpoItemCategoryHandle() : CPOItemCategoryBase_Record;
	public import function Icon() : weak< UIIcon_Record >;
	public import function IconHandle() : UIIcon_Record;
	public import function Counterpart() : weak< Item_Record >;
	public import function CounterpartHandle() : Item_Record;
	public import function DropSettings() : weak< ItemDropSettings_Record >;
	public import function DropSettingsHandle() : ItemDropSettings_Record;
	public import function ItemSecondaryAction() : weak< ItemAction_Record >;
	public import function ItemSecondaryActionHandle() : ItemAction_Record;
	public import function MinigameInstance() : weak< Minigame_Def_Record >;
	public import function MinigameInstanceHandle() : Minigame_Def_Record;
	public import function NextUpgradeItem() : weak< Item_Record >;
	public import function NextUpgradeItemHandle() : Item_Record;
	public import function SideUpgradeItem() : weak< Item_Record >;
	public import function SideUpgradeItemHandle() : Item_Record;
	public import function OnEquipStats() : weak< StatsList_Record >;
	public import function OnEquipStatsHandle() : StatsList_Record;
	public import function EquipPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetEquipPrereqsCount() : Int32;
	public import function GetEquipPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetEquipPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function EquipPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function SlotPartListPreset( out outList : array< weak< SlotItemPartPreset_Record > > );
	public import function GetSlotPartListPresetCount() : Int32;
	public import function GetSlotPartListPresetItem( index : Int32 ) : weak< SlotItemPartPreset_Record >;
	public import function GetSlotPartListPresetItemHandle( index : Int32 ) : SlotItemPartPreset_Record;
	public import function SlotPartListPresetContains( item : weak< SlotItemPartPreset_Record > ) : Bool;
	public import function EquipAreas( out outList : array< weak< EquipmentArea_Record > > );
	public import function GetEquipAreasCount() : Int32;
	public import function GetEquipAreasItem( index : Int32 ) : weak< EquipmentArea_Record >;
	public import function GetEquipAreasItemHandle( index : Int32 ) : EquipmentArea_Record;
	public import function EquipAreasContains( item : weak< EquipmentArea_Record > ) : Bool;
	public import function AppearanceSuffixes( out outList : array< weak< ItemsFactoryAppearanceSuffixBase_Record > > );
	public import function GetAppearanceSuffixesCount() : Int32;
	public import function GetAppearanceSuffixesItem( index : Int32 ) : weak< ItemsFactoryAppearanceSuffixBase_Record >;
	public import function GetAppearanceSuffixesItemHandle( index : Int32 ) : ItemsFactoryAppearanceSuffixBase_Record;
	public import function AppearanceSuffixesContains( item : weak< ItemsFactoryAppearanceSuffixBase_Record > ) : Bool;
	public import function PreviewBBoxOverride() : array< Vector3 >;
	public import function GetPreviewBBoxOverrideCount() : Int32;
	public import function GetPreviewBBoxOverrideItem( index : Int32 ) : Vector3;
	public import function PreviewBBoxOverrideContains( item : Vector3 ) : Bool;
	public import function GameplayRestrictions( out outList : array< weak< GameplayRestrictionStatusEffect_Record > > );
	public import function GetGameplayRestrictionsCount() : Int32;
	public import function GetGameplayRestrictionsItem( index : Int32 ) : weak< GameplayRestrictionStatusEffect_Record >;
	public import function GetGameplayRestrictionsItemHandle( index : Int32 ) : GameplayRestrictionStatusEffect_Record;
	public import function GameplayRestrictionsContains( item : weak< GameplayRestrictionStatusEffect_Record > ) : Bool;
	public import function AppearanceSuffixesOwnerOverride() : array< Bool >;
	public import function GetAppearanceSuffixesOwnerOverrideCount() : Int32;
	public import function GetAppearanceSuffixesOwnerOverrideItem( index : Int32 ) : Bool;
	public import function AppearanceSuffixesOwnerOverrideContains( item : Bool ) : Bool;
	public import function OnEquip( out outList : array< weak< GameplayLogicPackage_Record > > );
	public import function GetOnEquipCount() : Int32;
	public import function GetOnEquipItem( index : Int32 ) : weak< GameplayLogicPackage_Record >;
	public import function GetOnEquipItemHandle( index : Int32 ) : GameplayLogicPackage_Record;
	public import function OnEquipContains( item : weak< GameplayLogicPackage_Record > ) : Bool;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function OnAttach( out outList : array< weak< GameplayLogicPackage_Record > > );
	public import function GetOnAttachCount() : Int32;
	public import function GetOnAttachItem( index : Int32 ) : weak< GameplayLogicPackage_Record >;
	public import function GetOnAttachItemHandle( index : Int32 ) : GameplayLogicPackage_Record;
	public import function OnAttachContains( item : weak< GameplayLogicPackage_Record > ) : Bool;
	public import function SellPrice( out outList : array< weak< StatModifier_Record > > );
	public import function GetSellPriceCount() : Int32;
	public import function GetSellPriceItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetSellPriceItemHandle( index : Int32 ) : StatModifier_Record;
	public import function SellPriceContains( item : weak< StatModifier_Record > ) : Bool;
	public import function VisualTags() : array< CName >;
	public import function GetVisualTagsCount() : Int32;
	public import function GetVisualTagsItem( index : Int32 ) : CName;
	public import function VisualTagsContains( item : CName ) : Bool;
	public import function BuyPrice( out outList : array< weak< StatModifier_Record > > );
	public import function GetBuyPriceCount() : Int32;
	public import function GetBuyPriceItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetBuyPriceItemHandle( index : Int32 ) : StatModifier_Record;
	public import function BuyPriceContains( item : weak< StatModifier_Record > ) : Bool;
	public import function OnLooted( out outList : array< weak< GameplayLogicPackage_Record > > );
	public import function GetOnLootedCount() : Int32;
	public import function GetOnLootedItem( index : Int32 ) : weak< GameplayLogicPackage_Record >;
	public import function GetOnLootedItemHandle( index : Int32 ) : GameplayLogicPackage_Record;
	public import function OnLootedContains( item : weak< GameplayLogicPackage_Record > ) : Bool;
	public import function PlacementSlots( out outList : array< weak< AttachmentSlot_Record > > );
	public import function GetPlacementSlotsCount() : Int32;
	public import function GetPlacementSlotsItem( index : Int32 ) : weak< AttachmentSlot_Record >;
	public import function GetPlacementSlotsItemHandle( index : Int32 ) : AttachmentSlot_Record;
	public import function PlacementSlotsContains( item : weak< AttachmentSlot_Record > ) : Bool;
	public import function SlotPartList( out outList : array< weak< SlotItemPartListElement_Record > > );
	public import function GetSlotPartListCount() : Int32;
	public import function GetSlotPartListItem( index : Int32 ) : weak< SlotItemPartListElement_Record >;
	public import function GetSlotPartListItemHandle( index : Int32 ) : SlotItemPartListElement_Record;
	public import function SlotPartListContains( item : weak< SlotItemPartListElement_Record > ) : Bool;
	public import function HairSkinnedMeshComponents() : array< CName >;
	public import function GetHairSkinnedMeshComponentsCount() : Int32;
	public import function GetHairSkinnedMeshComponentsItem( index : Int32 ) : CName;
	public import function HairSkinnedMeshComponentsContains( item : CName ) : Bool;
	public import function Variants( out outList : array< weak< RandomVariant_Record > > );
	public import function GetVariantsCount() : Int32;
	public import function GetVariantsItem( index : Int32 ) : weak< RandomVariant_Record >;
	public import function GetVariantsItemHandle( index : Int32 ) : RandomVariant_Record;
	public import function VariantsContains( item : weak< RandomVariant_Record > ) : Bool;
	public import function AttachmentSlots( out outList : array< weak< AttachmentSlot_Record > > );
	public import function GetAttachmentSlotsCount() : Int32;
	public import function GetAttachmentSlotsItem( index : Int32 ) : weak< AttachmentSlot_Record >;
	public import function GetAttachmentSlotsItemHandle( index : Int32 ) : AttachmentSlot_Record;
	public import function AttachmentSlotsContains( item : weak< AttachmentSlot_Record > ) : Bool;
	public import function RequiredSlots( out outList : array< weak< ItemRequiredSlot_Record > > );
	public import function GetRequiredSlotsCount() : Int32;
	public import function GetRequiredSlotsItem( index : Int32 ) : weak< ItemRequiredSlot_Record >;
	public import function GetRequiredSlotsItemHandle( index : Int32 ) : ItemRequiredSlot_Record;
	public import function RequiredSlotsContains( item : weak< ItemRequiredSlot_Record > ) : Bool;
	public import function Parts( out outList : array< weak< Item_Record > > );
	public import function GetPartsCount() : Int32;
	public import function GetPartsItem( index : Int32 ) : weak< Item_Record >;
	public import function GetPartsItemHandle( index : Int32 ) : Item_Record;
	public import function PartsContains( item : weak< Item_Record > ) : Bool;
	public import function Connections( out outList : array< weak< ItemPartConnection_Record > > );
	public import function GetConnectionsCount() : Int32;
	public import function GetConnectionsItem( index : Int32 ) : weak< ItemPartConnection_Record >;
	public import function GetConnectionsItemHandle( index : Int32 ) : ItemPartConnection_Record;
	public import function ConnectionsContains( item : weak< ItemPartConnection_Record > ) : Bool;
	public import function AnimationParameters() : array< CName >;
	public import function GetAnimationParametersCount() : Int32;
	public import function GetAnimationParametersItem( index : Int32 ) : CName;
	public import function AnimationParametersContains( item : CName ) : Bool;
	public import function DisplayName() : CName;
	public import function DropObject() : CName;
	public import function AudioName() : CName;
	public import function EquipSoundMetadata() : CName;
	public import function AudioSwitchValue() : CName;
	public import function EntityName() : CName;
	public import function AppearanceName() : CName;
	public import function AudioSwitchName() : CName;
	public import function AnimFeatureName() : CName;
	public import function StateMachineName() : CName;
	public import function AppearanceResourceName() : CName;
	public import function AnimName() : CName;
	public import function AnimSetResource() : ResRef;
	public import function LocalizedDescription() : CName;
	public import function MovementPattern() : CName;
	public import function CameraForward() : Vector3;
	public import function CameraUp() : Vector3;
	public import function UpgradeCostMult() : Float;
	public import function GarmentOffset() : Int32;
	public import function Mass() : Float;
	public import function PowerLevelDeterminedByParent() : Bool;
	public import function UseHeadgearGarmentAggregator() : Bool;
	public import function IsSingleInstance() : Bool;
	public import function IsPart() : Bool;
	public import function Deprecated() : Bool;
	public import function IsGarment() : Bool;
	public import function IsCustomizable() : Bool;
	public import function EnableNpcRPGData() : Bool;
	public import function IsCached() : Bool;
	public import function QualityRestrictedByParent() : Bool;
	public import function CanDrop() : Bool;
	public import function ReplicateWhenNotActive() : Bool;
	public import function UsesVariants() : Bool;
	public import function IsCoreCW() : Bool;
	public import function UseNewSpawnMethod() : Bool;
}

importonly class ItemAction_Record extends ObjectAction_Record
{
	public import function IsDefaultLootChoice() : Bool;
	public import function RemoveAfterUse() : Bool;
}

importonly class ItemArrayQuery_Record extends ItemQuery_Record
{
	public import function MaxItems() : Int32;
	public import function MinItems() : Int32;
}

importonly class ItemBlueprint_Record extends TweakDBRecord
{
	public import function RootElement() : weak< ItemBlueprintElement_Record >;
	public import function RootElementHandle() : ItemBlueprintElement_Record;
}

importonly class ItemBlueprintElement_Record extends TweakDBRecord
{
	public import function Slot() : weak< AttachmentSlot_Record >;
	public import function SlotHandle() : AttachmentSlot_Record;
	public import function PrereqID() : weak< IPrereq_Record >;
	public import function PrereqIDHandle() : IPrereq_Record;
	public import function ChildElements( out outList : array< weak< ItemBlueprintElement_Record > > );
	public import function GetChildElementsCount() : Int32;
	public import function GetChildElementsItem( index : Int32 ) : weak< ItemBlueprintElement_Record >;
	public import function GetChildElementsItemHandle( index : Int32 ) : ItemBlueprintElement_Record;
	public import function ChildElementsContains( item : weak< ItemBlueprintElement_Record > ) : Bool;
}

importonly class ItemCategory_Record extends TweakDBRecord
{
	public import function Name() : CName;
	public import function LocalizedCategory() : CName;
	public import function Type() : gamedataItemCategory;
}

importonly class ItemCost_Record extends ObjectActionCost_Record
{
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
}

importonly class ItemCreationPrereq_Record extends StatPrereq_Record
{
}

importonly class ItemDropSettings_Record extends TweakDBRecord
{
	public import function DesiredAngularVelocity() : Float;
	public import function DesiredInitialRotation() : Float;
}

importonly class ItemList_Record extends TweakDBRecord
{
	public import function Items( out outList : array< weak< Item_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< Item_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : Item_Record;
	public import function ItemsContains( item : weak< Item_Record > ) : Bool;
}

importonly class ItemPartConnection_Record extends TweakDBRecord
{
	public import function AttachmentSlot() : weak< AttachmentSlot_Record >;
	public import function AttachmentSlotHandle() : AttachmentSlot_Record;
	public import function Parent() : Int32;
	public import function Child() : Int32;
}

importonly class ItemPartListElement_Record extends TweakDBRecord
{
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
	public import function StatModifierWeight( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifierWeightCount() : Int32;
	public import function GetStatModifierWeightItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifierWeightItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifierWeightContains( item : weak< StatModifier_Record > ) : Bool;
	public import function Weight() : Float;
}

importonly class ItemQuery_Record extends Query_Record
{
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function TagsToExclude() : array< CName >;
	public import function GetTagsToExcludeCount() : Int32;
	public import function GetTagsToExcludeItem( index : Int32 ) : CName;
	public import function TagsToExcludeContains( item : CName ) : Bool;
	public import function QualityLevelModifier() : Int32;
	public import function LevelBasedQuality() : Bool;
	public import function ExcludeUnlocked() : Bool;
}

importonly class ItemQueryElement_Record extends LootTableElement_Record
{
	public import function Query() : weak< ItemQuery_Record >;
	public import function QueryHandle() : ItemQuery_Record;
}

importonly class ItemRecipe_Record extends Item_Record
{
	public import function CraftingResult() : weak< CraftingResult_Record >;
	public import function CraftingResultHandle() : CraftingResult_Record;
	public import function HideOnItemsAdded( out outList : array< weak< Item_Record > > );
	public import function GetHideOnItemsAddedCount() : Int32;
	public import function GetHideOnItemsAddedItem( index : Int32 ) : weak< Item_Record >;
	public import function GetHideOnItemsAddedItemHandle( index : Int32 ) : Item_Record;
	public import function HideOnItemsAddedContains( item : weak< Item_Record > ) : Bool;
}

importonly class ItemRequiredSlot_Record extends TweakDBRecord
{
	public import function AttachmentSlot() : weak< AttachmentSlot_Record >;
	public import function AttachmentSlotHandle() : AttachmentSlot_Record;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
}

importonly class ItemStructure_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function EnumComment() : CName;
	public import function Type() : gamedataItemStructure;
}

importonly class ItemType_Record extends TweakDBRecord
{
	public import function Name() : CName;
	public import function LocalizedType() : CName;
	public import function AnimFeatureIndex() : Int32;
	public import function Type() : gamedataItemType;
}

importonly class ItemsFactoryAppearanceSuffixBase_Record extends TweakDBRecord
{
	public import function ScriptedSystem() : CName;
	public import function ScriptedFunction() : CName;
	public import function InstantSwitch() : Bool;
}

importonly class ItemsFactoryAppearanceSuffixOrder_Record extends TweakDBRecord
{
	public import function AppearanceSuffixes( out outList : array< weak< ItemsFactoryAppearanceSuffixBase_Record > > );
	public import function GetAppearanceSuffixesCount() : Int32;
	public import function GetAppearanceSuffixesItem( index : Int32 ) : weak< ItemsFactoryAppearanceSuffixBase_Record >;
	public import function GetAppearanceSuffixesItemHandle( index : Int32 ) : ItemsFactoryAppearanceSuffixBase_Record;
	public import function AppearanceSuffixesContains( item : weak< ItemsFactoryAppearanceSuffixBase_Record > ) : Bool;
}

importonly class JournalIcon_Record extends UIIcon_Record
{
}

importonly class KeepCurrentCoverCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function KeepCoverBonus() : Float;
}

importonly class KnifeThrowDelivery_Record extends GrenadeDeliveryMethod_Record
{
}

importonly class LCDScreen_Record extends BaseSign_Record
{
	public import function Message() : weak< ScreenMessageData_Record >;
	public import function MessageHandle() : ScreenMessageData_Record;
}

importonly class LandingFxMaterial_Record extends TweakDBRecord
{
	public import function Material() : weak< Material_Record >;
	public import function MaterialHandle() : Material_Record;
	public import function Effect() : ResRef;
}

importonly class LandingFxPackage_Record extends TweakDBRecord
{
	public import function Materials( out outList : array< weak< LandingFxMaterial_Record > > );
	public import function GetMaterialsCount() : Int32;
	public import function GetMaterialsItem( index : Int32 ) : weak< LandingFxMaterial_Record >;
	public import function GetMaterialsItemHandle( index : Int32 ) : LandingFxMaterial_Record;
	public import function MaterialsContains( item : weak< LandingFxMaterial_Record > ) : Bool;
}

importonly class Layout_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function LibraryPath() : ResRef;
}

importonly class LifePath_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function CaptionIcon() : weak< ChoiceCaptionIconPart_Record >;
	public import function CaptionIconHandle() : ChoiceCaptionIconPart_Record;
	public import function DisplayName() : CName;
	public import function NewGameSpawnTag() : CName;
	public import function EnumName() : CName;
	public import function Type() : gamedataLifePath;
}

importonly class LightPreset_Record extends TweakDBRecord
{
	public import function ColorMin() : array< Int32 >;
	public import function GetColorMinCount() : Int32;
	public import function GetColorMinItem( index : Int32 ) : Int32;
	public import function ColorMinContains( item : Int32 ) : Bool;
	public import function ColorMax() : array< Int32 >;
	public import function GetColorMaxCount() : Int32;
	public import function GetColorMaxItem( index : Int32 ) : Int32;
	public import function ColorMaxContains( item : Int32 ) : Bool;
	public import function Curve() : CName;
	public import function Strength() : Float;
	public import function Duration() : Float;
	public import function Time() : Float;
	public import function OverrideColorMin() : Bool;
	public import function On() : Bool;
	public import function Loop() : Bool;
	public import function Force() : Bool;
}

importonly class LinearAccuracy_Record extends Accuracy_Record
{
	public import function Duration() : Float;
}

importonly class LoadingTipsGroup_Record extends TweakDBRecord
{
	public import function HintLocalizationKeys() : array< CName >;
	public import function GetHintLocalizationKeysCount() : Int32;
	public import function GetHintLocalizationKeysItem( index : Int32 ) : CName;
	public import function HintLocalizationKeysContains( item : CName ) : Bool;
	public import function UnlockingFact() : CName;
}

importonly class LocomotionMode_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataLocomotionMode;
}

importonly class LookAtPart_Record extends TweakDBRecord
{
	public import function PartName() : CName;
	public import function Weight() : Float;
	public import function Suppress() : Float;
	public import function Mode() : Int32;
}

importonly class LookAtPreset_Record extends TweakDBRecord
{
	public import function LookAtParts( out outList : array< weak< LookAtPart_Record > > );
	public import function GetLookAtPartsCount() : Int32;
	public import function GetLookAtPartsItem( index : Int32 ) : weak< LookAtPart_Record >;
	public import function GetLookAtPartsItemHandle( index : Int32 ) : LookAtPart_Record;
	public import function LookAtPartsContains( item : weak< LookAtPart_Record > ) : Bool;
	public import function BodyPart() : CName;
	public import function SoftLimitDegrees() : Float;
	public import function TransitionSpeed() : Float;
	public import function Priority() : Int32;
	public import function Suppress() : Float;
	public import function BackLimitDegrees() : Float;
	public import function Mode() : Int32;
	public import function HardLimitDistance() : Float;
	public import function HardLimitDegrees() : Float;
	public import function FollowingSpeedFactorOverride() : Float;
	public import function OutTransitionSpeed() : Float;
	public import function CalculatePositionInParentSpace() : Bool;
	public import function HasOutTransition() : Bool;
	public import function AttachLeftHandtoRightHand() : Bool;
	public import function AttachRightHandtoLeftHand() : Bool;
}

importonly class LootInjectionSettings_Record extends TweakDBRecord
{
	public import function InjectedLoot() : weak< LootTable_Record >;
	public import function InjectedLootHandle() : LootTable_Record;
	public import function TagsExcludingBroken() : array< CName >;
	public import function GetTagsExcludingBrokenCount() : Int32;
	public import function GetTagsExcludingBrokenItem( index : Int32 ) : CName;
	public import function TagsExcludingBrokenContains( item : CName ) : Bool;
	public import function StatsExlcudingBroken( out outList : array< weak< Stat_Record > > );
	public import function GetStatsExlcudingBrokenCount() : Int32;
	public import function GetStatsExlcudingBrokenItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetStatsExlcudingBrokenItemHandle( index : Int32 ) : Stat_Record;
	public import function StatsExlcudingBrokenContains( item : weak< Stat_Record > ) : Bool;
	public import function BrokenChance() : Float;
	public import function BrokenOverrideChance() : Float;
}

importonly class LootItem_Record extends LootTableElement_Record
{
	public import function ItemID() : weak< Item_Record >;
	public import function ItemIDHandle() : Item_Record;
}

importonly class LootTable_Record extends TweakDBRecord
{
	public import function LootGenerationType() : String;
	public import function LootItems( out outList : array< weak< LootItem_Record > > );
	public import function GetLootItemsCount() : Int32;
	public import function GetLootItemsItem( index : Int32 ) : weak< LootItem_Record >;
	public import function GetLootItemsItemHandle( index : Int32 ) : LootItem_Record;
	public import function LootItemsContains( item : weak< LootItem_Record > ) : Bool;
	public import function Queries( out outList : array< weak< ItemQueryElement_Record > > );
	public import function GetQueriesCount() : Int32;
	public import function GetQueriesItem( index : Int32 ) : weak< ItemQueryElement_Record >;
	public import function GetQueriesItemHandle( index : Int32 ) : ItemQueryElement_Record;
	public import function QueriesContains( item : weak< ItemQueryElement_Record > ) : Bool;
	public import function LootTableInclusions( out outList : array< weak< LootTable_Record > > );
	public import function GetLootTableInclusionsCount() : Int32;
	public import function GetLootTableInclusionsItem( index : Int32 ) : weak< LootTable_Record >;
	public import function GetLootTableInclusionsItemHandle( index : Int32 ) : LootTable_Record;
	public import function LootTableInclusionsContains( item : weak< LootTable_Record > ) : Bool;
	public import function MaxItemsToLoot() : Int32;
	public import function MinItemsToLoot() : Int32;
}

importonly class LootTableElement_Record extends TweakDBRecord
{
	public import function PlayerPrereqID() : weak< IPrereq_Record >;
	public import function PlayerPrereqIDHandle() : IPrereq_Record;
	public import function DropChanceModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetDropChanceModifiersCount() : Int32;
	public import function GetDropChanceModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetDropChanceModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function DropChanceModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function QuantityModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetQuantityModifiersCount() : Int32;
	public import function GetQuantityModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetQuantityModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function QuantityModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function DropChance() : Float;
	public import function DropCountMin() : Int32;
	public import function DropCountMax() : Int32;
}

importonly class MappinClampingSettings_Record extends TweakDBRecord
{
	public import function EllipseOffset() : Vector2;
	public import function EllipseSize() : Vector2;
	public import function CustomTopRightEllipseSize() : Vector2;
	public import function CustomTopRightEllipseOffset() : Vector2;
	public import function CustomBottomRightEllipseOffset() : Vector2;
	public import function CustomTopLeftEllipseOffset() : Vector2;
	public import function ClampingRectangleRightAndBottom() : Vector2;
	public import function CustomBottomRightEllipseSize() : Vector2;
	public import function CustomTopLeftEllipseSize() : Vector2;
	public import function ClampingRectangleLeftAndTop() : Vector2;
	public import function CustomBottomLeftEllipseSize() : Vector2;
	public import function CustomBottomLeftEllipseOffset() : Vector2;
	public import function EllipseShapeSize() : Vector2;
	public import function MinimumClampPercent() : Float;
	public import function ClampSmoothing() : Float;
	public import function CustomTopLeftEllipse() : Bool;
	public import function UseSpecialShapeLogic() : Bool;
	public import function CustomTopRightEllipse() : Bool;
	public import function CustomBottomLeftEllipse() : Bool;
	public import function DisableTopRightEllipse() : Bool;
	public import function CustomBottomRightEllipse() : Bool;
	public import function DisableBottomRightEllipse() : Bool;
	public import function DisableBottomLeftEllipse() : Bool;
	public import function DisableTopLeftEllipse() : Bool;
	public import function UseEllipseShape() : Bool;
}

importonly class MappinDefinition_Record extends Base_MappinDefinition_Record
{
	public import function PossibleVariants( out outList : array< weak< MappinVariant_Record > > );
	public import function GetPossibleVariantsCount() : Int32;
	public import function GetPossibleVariantsItem( index : Int32 ) : weak< MappinVariant_Record >;
	public import function GetPossibleVariantsItemHandle( index : Int32 ) : MappinVariant_Record;
	public import function PossibleVariantsContains( item : weak< MappinVariant_Record > ) : Bool;
}

importonly class MappinPhase_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataMappinPhase;
}

importonly class MappinPhaseDefinition_Record extends TweakDBRecord
{
	public import function Phase() : weak< MappinPhase_Record >;
	public import function PhaseHandle() : MappinPhase_Record;
	public import function Variant() : weak< MappinVariant_Record >;
	public import function VariantHandle() : MappinVariant_Record;
}

importonly class MappinUICustomOpacityParams_Record extends TweakDBRecord
{
	public import function DistanceWhenFullyVisible() : Float;
	public import function VisibilityConeStartAngle() : Float;
	public import function DistanceWhenFullyHidden() : Float;
	public import function VisibilityConeEndAngle() : Float;
	public import function VisibilityConeMaximumOpacity() : Float;
}

importonly class MappinUIFilterGroup_Record extends TweakDBRecord
{
	public import function FilterType() : weak< WorldMapFilter_Record >;
	public import function FilterTypeHandle() : WorldMapFilter_Record;
	public import function Mappins( out outList : array< weak< MappinVariant_Record > > );
	public import function GetMappinsCount() : Int32;
	public import function GetMappinsItem( index : Int32 ) : weak< MappinVariant_Record >;
	public import function GetMappinsItemHandle( index : Int32 ) : MappinVariant_Record;
	public import function MappinsContains( item : weak< MappinVariant_Record > ) : Bool;
	public import function FilterName() : CName;
	public import function ShouldCollectMappins() : Bool;
}

importonly class MappinUIGlobalProfile_Record extends TweakDBRecord
{
	public import function NameplateVisibleInTier() : array< Bool >;
	public import function GetNameplateVisibleInTierCount() : Int32;
	public import function GetNameplateVisibleInTierItem( index : Int32 ) : Bool;
	public import function NameplateVisibleInTierContains( item : Bool ) : Bool;
	public import function VerticalRelationVisibleRangeMin() : Float;
	public import function VerticalRelationTolerance() : Float;
	public import function VerticalRelationVisibleRangeMax() : Float;
	public import function GpsPortalIconScale() : Float;
	public import function CompletedPOIOpacity() : Float;
	public import function NameplateVisibleInBraindance() : Bool;
}

importonly class MappinUIParamGroup_Record extends TweakDBRecord
{
	public import function MinFactor() : Float;
	public import function MaxValue() : Float;
	public import function ValueOffset() : Float;
	public import function MaxFactor() : Float;
	public import function MinValue() : Float;
	public import function QuadraticPeakMultiplier() : Float;
	public import function Quadratic() : Bool;
}

importonly class MappinUIPreventionSettings_Record extends TweakDBRecord
{
	public import function PreventionMappinMaxDistance() : Float;
	public import function PreventionVehicleMappinMaxDistance() : Float;
	public import function PreventionDetectionThresholdForVisionCone() : Float;
}

importonly class MappinUIRuntimeProfile_Record extends TweakDBRecord
{
	public import function ScaleDistanceScanningParams() : weak< MappinUIParamGroup_Record >;
	public import function ScaleDistanceScanningParamsHandle() : MappinUIParamGroup_Record;
	public import function ClampingParams() : weak< MappinClampingSettings_Record >;
	public import function ClampingParamsHandle() : MappinClampingSettings_Record;
	public import function OpacityDistanceParams() : weak< MappinUIParamGroup_Record >;
	public import function OpacityDistanceParamsHandle() : MappinUIParamGroup_Record;
	public import function ScaleDistanceParams() : weak< MappinUIParamGroup_Record >;
	public import function ScaleDistanceParamsHandle() : MappinUIParamGroup_Record;
	public import function OpacityAngleParams() : weak< MappinUIParamGroup_Record >;
	public import function OpacityAngleParamsHandle() : MappinUIParamGroup_Record;
	public import function OpacityCustomParams() : weak< MappinUICustomOpacityParams_Record >;
	public import function OpacityCustomParamsHandle() : MappinUICustomOpacityParams_Record;
	public import function VisibleInTier() : array< Bool >;
	public import function GetVisibleInTierCount() : Int32;
	public import function GetVisibleInTierItem( index : Int32 ) : Bool;
	public import function VisibleInTierContains( item : Bool ) : Bool;
	public import function WorldOffset() : Vector3;
	public import function ClampEllipseSize() : Vector2;
	public import function ClampRectMargin() : Vector2;
	public import function ScreenOffset() : Vector2;
	public import function Priority() : Int32;
	public import function ShowDistanceMinRange() : Float;
	public import function ShowNameMinRange() : Float;
	public import function HoverRadius() : Float;
	public import function ShowDistance() : Bool;
	public import function DynamicClamping() : Bool;
	public import function ClampY() : Bool;
	public import function VisibleInScanning() : Bool;
	public import function ClampX() : Bool;
	public import function VisibleInBraindance() : Bool;
	public import function ScaleByDistance() : Bool;
	public import function KeepNameplate() : Bool;
	public import function UseQuestProperties() : Bool;
	public import function ShowTrackedIcon() : Bool;
	public import function IsLoot() : Bool;
}

importonly class MappinUISettings_Record extends MappinUIRuntimeProfile_Record
{
	public import function CompletedPOIOpacity() : Float;
	public import function ShowInTier3() : Bool;
}

importonly class MappinUISpawnProfile_Record extends TweakDBRecord
{
	public import function SpawnDistance() : Float;
	public import function DespawnDistance() : Float;
}

importonly class MappinVariant_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataMappinVariant;
}

importonly class MappinsGroup_Record extends TweakDBRecord
{
	public import function Mappins( out outList : array< weak< MappinVariant_Record > > );
	public import function GetMappinsCount() : Int32;
	public import function GetMappinsItem( index : Int32 ) : weak< MappinVariant_Record >;
	public import function GetMappinsItemHandle( index : Int32 ) : MappinVariant_Record;
	public import function MappinsContains( item : weak< MappinVariant_Record > ) : Bool;
	public import function GroupName() : CName;
	public import function WidgetState() : CName;
}

importonly class Material_Record extends TweakDBRecord
{
	public import function Name() : CName;
}

importonly class MaterialFx_Record extends TweakDBRecord
{
	public import function Impact_decal() : array< ResRef >;
	public import function GetImpact_decalCount() : Int32;
	public import function GetImpact_decalItem( index : Int32 ) : ResRef;
	public import function Impact_reflected_effect() : array< ResRef >;
	public import function GetImpact_reflected_effectCount() : Int32;
	public import function GetImpact_reflected_effectItem( index : Int32 ) : ResRef;
	public import function Impact_pierce_splatter_near() : array< ResRef >;
	public import function GetImpact_pierce_splatter_nearCount() : Int32;
	public import function GetImpact_pierce_splatter_nearItem( index : Int32 ) : ResRef;
	public import function Impact_underwater_effect() : array< ResRef >;
	public import function GetImpact_underwater_effectCount() : Int32;
	public import function GetImpact_underwater_effectItem( index : Int32 ) : ResRef;
	public import function Impact_pierce_splatter_far() : array< ResRef >;
	public import function GetImpact_pierce_splatter_farCount() : Int32;
	public import function GetImpact_pierce_splatter_farItem( index : Int32 ) : ResRef;
	public import function Impact_main_effect() : array< ResRef >;
	public import function GetImpact_main_effectCount() : Int32;
	public import function GetImpact_main_effectItem( index : Int32 ) : ResRef;
	public import function Impact_pierce_effect() : array< ResRef >;
	public import function GetImpact_pierce_effectCount() : Int32;
	public import function GetImpact_pierce_effectItem( index : Int32 ) : ResRef;
	public import function Impact_dismemberment_piercing() : array< ResRef >;
	public import function GetImpact_dismemberment_piercingCount() : Int32;
	public import function GetImpact_dismemberment_piercingItem( index : Int32 ) : ResRef;
	public import function Impact_pierce_decal() : array< ResRef >;
	public import function GetImpact_pierce_decalCount() : Int32;
	public import function GetImpact_pierce_decalItem( index : Int32 ) : ResRef;
	public import function Pierce_near_distance() : Float;
	public import function Pierce_far_distance() : Float;
	public import function Reflected_angle_max() : Float;
	public import function Pierce_enter() : Bool;
	public import function Pierce_exit() : Bool;
}

importonly class MeleeAttackDirection_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataMeleeAttackDirection;
}

importonly class MetaQuest_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataMetaQuest;
}

importonly class MiniGame_AllSymbols_Record extends TweakDBRecord
{
	public import function SymbolsWithRarity( out outList : array< weak< MiniGame_SymbolsWithRarity_Record > > );
	public import function GetSymbolsWithRarityCount() : Int32;
	public import function GetSymbolsWithRarityItem( index : Int32 ) : weak< MiniGame_SymbolsWithRarity_Record >;
	public import function GetSymbolsWithRarityItemHandle( index : Int32 ) : MiniGame_SymbolsWithRarity_Record;
	public import function SymbolsWithRarityContains( item : weak< MiniGame_SymbolsWithRarity_Record > ) : Bool;
}

importonly class MiniGame_AllSymbols_inline0_Record extends MiniGame_SymbolsWithRarity_Record
{
}

importonly class MiniGame_AllSymbols_inline1_Record extends MiniGame_SymbolsWithRarity_Record
{
}

importonly class MiniGame_AllSymbols_inline2_Record extends MiniGame_SymbolsWithRarity_Record
{
}

importonly class MiniGame_AllSymbols_inline3_Record extends MiniGame_SymbolsWithRarity_Record
{
}

importonly class MiniGame_AllSymbols_inline4_Record extends MiniGame_SymbolsWithRarity_Record
{
}

importonly class MiniGame_SymbolsWithRarity_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Symbol() : String;
	public import function Probability() : Float;
}

importonly class MiniGame_Trap_Record extends TweakDBRecord
{
	public import function TrapType() : weak< MinigameTrapType_Record >;
	public import function TrapTypeHandle() : MinigameTrapType_Record;
	public import function TrapIcon() : weak< UIIcon_Record >;
	public import function TrapIconHandle() : UIIcon_Record;
	public import function TrapDescription() : CName;
	public import function TrapName() : CName;
	public import function SpawnProbability() : Float;
	public import function NegativeTrap() : Bool;
}

importonly class MinigameAction_Record extends ObjectAction_Record
{
	public import function JournalEntry() : String;
	public import function Category() : weak< MinigameCategory_Record >;
	public import function CategoryHandle() : MinigameCategory_Record;
	public import function Reward() : weak< RewardBase_Record >;
	public import function RewardHandle() : RewardBase_Record;
	public import function Type() : weak< MinigameActionType_Record >;
	public import function TypeHandle() : MinigameActionType_Record;
	public import function FactName() : CName;
	public import function FactValue() : Int32;
	public import function Duration() : Float;
	public import function Complexity() : Float;
	public import function MemoryCost() : Float;
	public import function ShowPopup() : Bool;
}

importonly class MinigameActionType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataMinigameActionType;
}

importonly class MinigameCategory_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataMinigameCategory;
}

importonly class MinigameTrapType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataMinigameTrapType;
}

importonly class Minigame_Def_Record extends TweakDBRecord
{
	public import function DefaultTrap() : weak< MiniGame_Trap_Record >;
	public import function DefaultTrapHandle() : MiniGame_Trap_Record;
	public import function OverrideProgramsList( out outList : array< weak< Program_Record > > );
	public import function GetOverrideProgramsListCount() : Int32;
	public import function GetOverrideProgramsListItem( index : Int32 ) : weak< Program_Record >;
	public import function GetOverrideProgramsListItemHandle( index : Int32 ) : Program_Record;
	public import function OverrideProgramsListContains( item : weak< Program_Record > ) : Bool;
	public import function AdditionalProgramsList( out outList : array< weak< Program_Record > > );
	public import function GetAdditionalProgramsListCount() : Int32;
	public import function GetAdditionalProgramsListItem( index : Int32 ) : weak< Program_Record >;
	public import function GetAdditionalProgramsListItemHandle( index : Int32 ) : Program_Record;
	public import function AdditionalProgramsListContains( item : weak< Program_Record > ) : Bool;
	public import function ForbiddenProgramsList( out outList : array< weak< Program_Record > > );
	public import function GetForbiddenProgramsListCount() : Int32;
	public import function GetForbiddenProgramsListItem( index : Int32 ) : weak< Program_Record >;
	public import function GetForbiddenProgramsListItemHandle( index : Int32 ) : Program_Record;
	public import function ForbiddenProgramsListContains( item : weak< Program_Record > ) : Bool;
	public import function GridTraps( out outList : array< weak< RowTraps_Record > > );
	public import function GetGridTrapsCount() : Int32;
	public import function GetGridTrapsItem( index : Int32 ) : weak< RowTraps_Record >;
	public import function GetGridTrapsItemHandle( index : Int32 ) : RowTraps_Record;
	public import function GridTrapsContains( item : weak< RowTraps_Record > ) : Bool;
	public import function GridSymbols( out outList : array< weak< RowSymbols_Record > > );
	public import function GetGridSymbolsCount() : Int32;
	public import function GetGridSymbolsItem( index : Int32 ) : weak< RowSymbols_Record >;
	public import function GetGridSymbolsItemHandle( index : Int32 ) : RowSymbols_Record;
	public import function GridSymbolsContains( item : weak< RowSymbols_Record > ) : Bool;
	public import function BufferFullExitText() : CName;
	public import function TimeOutExitText() : CName;
	public import function GenericExitText() : CName;
	public import function SuccessExitText() : CName;
	public import function GreatSuccessExitText() : CName;
	public import function FailExitText() : CName;
	public import function CanceledExitText() : CName;
	public import function ExtraDifficulty() : Float;
	public import function GridSize() : Int32;
	public import function OverlapProbability() : Float;
	public import function TrapsProbability() : Float;
	public import function TimeLimit() : Float;
	public import function BufferSize() : Int32;
	public import function UseProgression() : Bool;
	public import function SaveSeed() : Bool;
	public import function NoTraps() : Bool;
}

importonly class ModifyAttackCritChanceEffector_Record extends Effector_Record
{
	public import function CritChance( out outList : array< weak< StatModifier_Record > > );
	public import function GetCritChanceCount() : Int32;
	public import function GetCritChanceItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetCritChanceItemHandle( index : Int32 ) : StatModifier_Record;
	public import function CritChanceContains( item : weak< StatModifier_Record > ) : Bool;
}

importonly class ModifyStaminaHandlerEffector_Record extends Effector_Record
{
	public import function OpSymbol() : CName;
}

importonly class ModifyStatPoolCustomLimitEffector_Record extends Effector_Record
{
	public import function StatPoolType() : weak< StatPool_Record >;
	public import function StatPoolTypeHandle() : StatPool_Record;
	public import function Value() : Float;
	public import function UsePercent() : Bool;
}

importonly class ModifyStatPoolModifierEffector_Record extends Effector_Record
{
	public import function ModificationType() : String;
	public import function StatPoolType() : String;
	public import function PoolModifier() : weak< PoolValueModifier_Record >;
	public import function PoolModifierHandle() : PoolValueModifier_Record;
}

importonly class ModifyStatPoolValueEffector_Record extends Effector_Record
{
	public import function StatPoolUpdates( out outList : array< weak< StatPoolUpdate_Record > > );
	public import function GetStatPoolUpdatesCount() : Int32;
	public import function GetStatPoolUpdatesItem( index : Int32 ) : weak< StatPoolUpdate_Record >;
	public import function GetStatPoolUpdatesItemHandle( index : Int32 ) : StatPoolUpdate_Record;
	public import function StatPoolUpdatesContains( item : weak< StatPoolUpdate_Record > ) : Bool;
	public import function ApplicationTarget() : CName;
	public import function UsePercent() : Bool;
	public import function SetValue() : Bool;
}

importonly class MovementParam_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function MaxSpeed() : Float;
	public import function Acceleration() : Float;
	public import function Deceleration() : Float;
	public import function RotationSpeed() : Float;
	public import function Type() : gamedataMovementType;
}

importonly class MovementParams_Record extends TweakDBRecord
{
	public import function Params( out outList : array< weak< MovementParam_Record > > );
	public import function GetParamsCount() : Int32;
	public import function GetParamsItem( index : Int32 ) : weak< MovementParam_Record >;
	public import function GetParamsItemHandle( index : Int32 ) : MovementParam_Record;
	public import function ParamsContains( item : weak< MovementParam_Record > ) : Bool;
}

importonly class MovementPolicy_Record extends TweakDBRecord
{
	public import function Ring() : weak< AIRingType_Record >;
	public import function RingHandle() : AIRingType_Record;
	public import function StrafingTarget() : weak< AIActionTarget_Record >;
	public import function StrafingTargetHandle() : AIActionTarget_Record;
	public import function Target() : weak< AIActionTarget_Record >;
	public import function TargetHandle() : AIActionTarget_Record;
	public import function DestinationOrientationPosition() : weak< AIActionTarget_Record >;
	public import function DestinationOrientationPositionHandle() : AIActionTarget_Record;
	public import function BlockedTags( out outList : array< weak< MovementPolicyTagList_Record > > );
	public import function GetBlockedTagsCount() : Int32;
	public import function GetBlockedTagsItem( index : Int32 ) : weak< MovementPolicyTagList_Record >;
	public import function GetBlockedTagsItemHandle( index : Int32 ) : MovementPolicyTagList_Record;
	public import function BlockedTagsContains( item : weak< MovementPolicyTagList_Record > ) : Bool;
	public import function AllowedTags( out outList : array< weak< MovementPolicyTagList_Record > > );
	public import function GetAllowedTagsCount() : Int32;
	public import function GetAllowedTagsItem( index : Int32 ) : weak< MovementPolicyTagList_Record >;
	public import function GetAllowedTagsItemHandle( index : Int32 ) : MovementPolicyTagList_Record;
	public import function AllowedTagsContains( item : weak< MovementPolicyTagList_Record > ) : Bool;
	public import function KeepLineOfSight() : CName;
	public import function MovementType() : CName;
	public import function LineOfSightPointPreference() : CName;
	public import function CirclingDirection() : CName;
	public import function MaxPathLengthToDirectDistanceRatioCurve() : CName;
	public import function DebugName() : CName;
	public import function SpatialHintMults() : Vector3;
	public import function Tolerance() : Float;
	public import function StrafingPredictionTime() : Float;
	public import function Distance() : Float;
	public import function ZDiff() : Float;
	public import function AvoidThreatRange() : Float;
	public import function RingToleranceMult() : Float;
	public import function RingToleranceOffset() : Float;
	public import function AvoidThreatCost() : Float;
	public import function RingDistanceOffset() : Float;
	public import function StrafingRotationOffset() : Float;
	public import function StrafingPredictionVelocityMax() : Float;
	public import function RingDistanceMult() : Float;
	public import function DynamicTargetUpdateTimer() : Float;
	public import function DynamicTargetUpdateDistance() : Float;
	public import function MinDistance() : Float;
	public import function DeadAngle() : Float;
	public import function MaxPathLength() : Float;
	public import function AvoidThreatIgnoringDirection() : Bool;
	public import function DontUseStop() : Bool;
	public import function IgnoreNavigation() : Bool;
	public import function UseOffMeshBlockedTags() : Bool;
	public import function IgnoreCollisionAvoidance() : Bool;
	public import function SymmetricAnglesScores() : Bool;
	public import function DontUseStart() : Bool;
	public import function IgnoreSpotReservation() : Bool;
	public import function IgnoreRestrictedMovementArea() : Bool;
	public import function UseOffMeshAllowedTags() : Bool;
	public import function IgnoreLoSPrecheck() : Bool;
	public import function AvoidSafeArea() : Bool;
	public import function UseFollowSlots() : Bool;
	public import function AvoidThreat() : Bool;
	public import function CalculateStartTangent() : Bool;
	public import function AvoidObstacleWithinTolerance() : Bool;
	public import function StopOnObstacle() : Bool;
	public import function GetOutOfWay() : Bool;
}

importonly class MovementPolicyTagList_Record extends TweakDBRecord
{
	public import function Condition() : weak< AIActionCondition_Record >;
	public import function ConditionHandle() : AIActionCondition_Record;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
}

importonly class MultiPrereq_Record extends IPrereq_Record
{
	public import function NestedPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetNestedPrereqsCount() : Int32;
	public import function GetNestedPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetNestedPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function NestedPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function AggregationType() : CName;
}

importonly class MutablePoolValueModifier_Record extends PoolValueModifier_Record
{
	public import function EnabledMod() : weak< StatModifier_Record >;
	public import function EnabledModHandle() : StatModifier_Record;
	public import function DelayOnChangeMod() : weak< StatModifier_Record >;
	public import function DelayOnChangeModHandle() : StatModifier_Record;
	public import function StartDelayMods( out outList : array< weak< StatModifier_Record > > );
	public import function GetStartDelayModsCount() : Int32;
	public import function GetStartDelayModsItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStartDelayModsItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StartDelayModsContains( item : weak< StatModifier_Record > ) : Bool;
	public import function RangeEndMods( out outList : array< weak< StatModifier_Record > > );
	public import function GetRangeEndModsCount() : Int32;
	public import function GetRangeEndModsItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetRangeEndModsItemHandle( index : Int32 ) : StatModifier_Record;
	public import function RangeEndModsContains( item : weak< StatModifier_Record > ) : Bool;
	public import function RangeBeginMods( out outList : array< weak< StatModifier_Record > > );
	public import function GetRangeBeginModsCount() : Int32;
	public import function GetRangeBeginModsItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetRangeBeginModsItemHandle( index : Int32 ) : StatModifier_Record;
	public import function RangeBeginModsContains( item : weak< StatModifier_Record > ) : Bool;
	public import function ValuePerSecMods( out outList : array< weak< StatModifier_Record > > );
	public import function GetValuePerSecModsCount() : Int32;
	public import function GetValuePerSecModsItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetValuePerSecModsItemHandle( index : Int32 ) : StatModifier_Record;
	public import function ValuePerSecModsContains( item : weak< StatModifier_Record > ) : Bool;
}

importonly class NPCBehaviorState_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataNPCBehaviorState;
}

importonly class NPCEquipmentGroup_Record extends TweakDBRecord
{
	public import function EquipmentItems( out outList : array< weak< NPCEquipmentGroupEntry_Record > > );
	public import function GetEquipmentItemsCount() : Int32;
	public import function GetEquipmentItemsItem( index : Int32 ) : weak< NPCEquipmentGroupEntry_Record >;
	public import function GetEquipmentItemsItemHandle( index : Int32 ) : NPCEquipmentGroupEntry_Record;
	public import function EquipmentItemsContains( item : weak< NPCEquipmentGroupEntry_Record > ) : Bool;
}

importonly class NPCEquipmentGroupEntry_Record extends TweakDBRecord
{
}

importonly class NPCEquipmentItem_Record extends NPCEquipmentGroupEntry_Record
{
	public import function OnBodySlot() : weak< AttachmentSlot_Record >;
	public import function OnBodySlotHandle() : AttachmentSlot_Record;
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
	public import function EquipSlot() : weak< AttachmentSlot_Record >;
	public import function EquipSlotHandle() : AttachmentSlot_Record;
	public import function EquipCondition( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetEquipConditionCount() : Int32;
	public import function GetEquipConditionItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetEquipConditionItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function EquipConditionContains( item : weak< AIActionCondition_Record > ) : Bool;
	public import function UnequipCondition( out outList : array< weak< AIActionCondition_Record > > );
	public import function GetUnequipConditionCount() : Int32;
	public import function GetUnequipConditionItem( index : Int32 ) : weak< AIActionCondition_Record >;
	public import function GetUnequipConditionItemHandle( index : Int32 ) : AIActionCondition_Record;
	public import function UnequipConditionContains( item : weak< AIActionCondition_Record > ) : Bool;
}

importonly class NPCEquipmentItemPool_Record extends NPCEquipmentGroupEntry_Record
{
	public import function Pool( out outList : array< weak< NPCEquipmentItemsPoolEntry_Record > > );
	public import function GetPoolCount() : Int32;
	public import function GetPoolItem( index : Int32 ) : weak< NPCEquipmentItemsPoolEntry_Record >;
	public import function GetPoolItemHandle( index : Int32 ) : NPCEquipmentItemsPoolEntry_Record;
	public import function PoolContains( item : weak< NPCEquipmentItemsPoolEntry_Record > ) : Bool;
}

importonly class NPCEquipmentItemsPoolEntry_Record extends TweakDBRecord
{
	public import function Items( out outList : array< weak< NPCEquipmentItem_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< NPCEquipmentItem_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : NPCEquipmentItem_Record;
	public import function ItemsContains( item : weak< NPCEquipmentItem_Record > ) : Bool;
	public import function MinLevel() : Int32;
	public import function Weight() : Float;
}

importonly class NPCHighLevelState_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataNPCHighLevelState;
}

importonly class NPCQuestAffiliation_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataNPCQuestAffiliation;
}

importonly class NPCRarity_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function EnumName() : CName;
	public import function RarityValue() : Float;
	public import function NotAvailableDynamically() : Bool;
	public import function Type() : gamedataNPCRarity;
}

importonly class NPCStanceState_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataNPCStanceState;
}

importonly class NPCType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataNPCType;
}

importonly class NPCTypePrereq_Record extends IPrereq_Record
{
	public import function AllowedTypes( out outList : array< weak< NPCType_Record > > );
	public import function GetAllowedTypesCount() : Int32;
	public import function GetAllowedTypesItem( index : Int32 ) : weak< NPCType_Record >;
	public import function GetAllowedTypesItemHandle( index : Int32 ) : NPCType_Record;
	public import function AllowedTypesContains( item : weak< NPCType_Record > ) : Bool;
	public import function Invert() : Bool;
}

importonly class NPCUpperBodyState_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataNPCUpperBodyState;
}

importonly class NetworkPingingParameteres_Record extends TweakDBRecord
{
	public import function VirtualNetwork() : weak< VirtualNetwork_Record >;
	public import function VirtualNetworkHandle() : VirtualNetwork_Record;
	public import function DirectPingDuration() : Float;
	public import function PingRange() : Float;
	public import function PulseRange() : Float;
	public import function RevealMasterAfterLeavingFocusDuration() : Float;
	public import function NetworkRevealDuration() : Float;
	public import function RevealLinksAfterLeavingFocusDuration() : Float;
	public import function SpacePingDuration() : Float;
	public import function MaxFreePingLinks() : Int32;
	public import function AmmountOfIntervals() : Int32;
	public import function SpacePingAppearModifier() : Float;
	public import function AllowSimultanousPinging() : Bool;
	public import function ForceInstantBeamKill() : Bool;
	public import function ShouldNetworkElementsPersistAfterFocus() : Bool;
	public import function RevealSlave() : Bool;
	public import function UsePulse() : Bool;
	public import function ShouldRevealNetworkAfterPulse() : Bool;
	public import function SuppressPingIfBackdoorsFound() : Bool;
	public import function RevealMaster() : Bool;
	public import function PulseRealObjects() : Bool;
	public import function ReavealNetworkOnMaster() : Bool;
	public import function QuickHacksExposedByDefaul() : Bool;
	public import function ShowOnlyTargetQuickHacks() : Bool;
}

importonly class NetworkPresetBinderParameters_Record extends TweakDBRecord
{
	public import function PingPresetID() : weak< NetworkPingingParameteres_Record >;
	public import function PingPresetIDHandle() : NetworkPingingParameteres_Record;
}

importonly class NewPerk_Record extends TweakDBRecord
{
	public import function Loc_desc_key() : String;
	public import function Loc_name_key() : String;
	public import function EnumComment() : String;
	public import function PerkIcon() : weak< UIIcon_Record >;
	public import function PerkIconHandle() : UIIcon_Record;
	public import function Slot() : weak< NewPerkSlot_Record >;
	public import function SlotHandle() : NewPerkSlot_Record;
	public import function PerkWeaponGroup() : weak< PerkWeaponGroup_Record >;
	public import function PerkWeaponGroupHandle() : PerkWeaponGroup_Record;
	public import function Category() : weak< NewPerkCategory_Record >;
	public import function CategoryHandle() : NewPerkCategory_Record;
	public import function Tier() : weak< NewPerkTier_Record >;
	public import function TierHandle() : NewPerkTier_Record;
	public import function Attribute() : weak< AttributeData_Record >;
	public import function AttributeHandle() : AttributeData_Record;
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function DataPackage() : weak< GameplayLogicPackage_Record >;
	public import function DataPackageHandle() : GameplayLogicPackage_Record;
	public import function UiData() : weak< NewPerkLevelUIData_Record >;
	public import function UiDataHandle() : NewPerkLevelUIData_Record;
	public import function Requirement() : weak< IPrereq_Record >;
	public import function RequirementHandle() : IPrereq_Record;
	public import function Levels( out outList : array< weak< NewPerkLevelData_Record > > );
	public import function GetLevelsCount() : Int32;
	public import function GetLevelsItem( index : Int32 ) : weak< NewPerkLevelData_Record >;
	public import function GetLevelsItemHandle( index : Int32 ) : NewPerkLevelData_Record;
	public import function LevelsContains( item : weak< NewPerkLevelData_Record > ) : Bool;
	public import function RequiresPerks( out outList : array< weak< NewPerk_Record > > );
	public import function GetRequiresPerksCount() : Int32;
	public import function GetRequiresPerksItem( index : Int32 ) : weak< NewPerk_Record >;
	public import function GetRequiresPerksItemHandle( index : Int32 ) : NewPerk_Record;
	public import function RequiresPerksContains( item : weak< NewPerk_Record > ) : Bool;
	public import function IconPath() : CName;
	public import function EnumName() : CName;
	public import function BinkPath() : ResRef;
	public import function Type() : gamedataNewPerkType;
}

importonly class NewPerkCategory_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataNewPerkCategoryType;
}

importonly class NewPerkLevelData_Record extends TweakDBRecord
{
	public import function Loc_name_key() : String;
	public import function Loc_desc_key() : String;
	public import function DataPackage() : weak< GameplayLogicPackage_Record >;
	public import function DataPackageHandle() : GameplayLogicPackage_Record;
	public import function UiData() : weak< NewPerkLevelUIData_Record >;
	public import function UiDataHandle() : NewPerkLevelUIData_Record;
	public import function PointsCost() : Int32;
}

importonly class NewPerkLevelUIData_Record extends TweakDBRecord
{
	public import function IntValues() : array< Int32 >;
	public import function GetIntValuesCount() : Int32;
	public import function GetIntValuesItem( index : Int32 ) : Int32;
	public import function IntValuesContains( item : Int32 ) : Bool;
	public import function FloatValues() : array< Float >;
	public import function GetFloatValuesCount() : Int32;
	public import function GetFloatValuesItem( index : Int32 ) : Float;
	public import function FloatValuesContains( item : Float ) : Bool;
	public import function NameValues() : array< CName >;
	public import function GetNameValuesCount() : Int32;
	public import function GetNameValuesItem( index : Int32 ) : CName;
	public import function NameValuesContains( item : CName ) : Bool;
}

importonly class NewPerkSlot_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataNewPerkSlotType;
}

importonly class NewPerkTier_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function Loc_name_key() : String;
	public import function EnumName() : CName;
	public import function RequiredAttributePoints() : Int32;
	public import function Type() : gamedataNewPerkTierType;
}

importonly class NewSkillsProficiency_Record extends Proficiency_Record
{
}

importonly class NewsFeedTitle_Record extends TweakDBRecord
{
	public import function TitlesList() : array< CName >;
	public import function GetTitlesListCount() : Int32;
	public import function GetTitlesListItem( index : Int32 ) : CName;
	public import function TitlesListContains( item : CName ) : Bool;
}

importonly class NonLinearAccuracy_Record extends Accuracy_Record
{
	public import function Exponent() : Float;
	public import function TimeFactor() : Float;
}

importonly class NumberPlate_Record extends LCDScreen_Record
{
}

importonly class ObjectAction_Record extends TweakDBRecord
{
	public import function GameplayCategory() : weak< ObjectActionGameplayCategory_Record >;
	public import function GameplayCategoryHandle() : ObjectActionGameplayCategory_Record;
	public import function HackCategory() : weak< HackCategory_Record >;
	public import function HackCategoryHandle() : HackCategory_Record;
	public import function ObjectActionType() : weak< ObjectActionType_Record >;
	public import function ObjectActionTypeHandle() : ObjectActionType_Record;
	public import function ObjectActionUI() : weak< InteractionBase_Record >;
	public import function ObjectActionUIHandle() : InteractionBase_Record;
	public import function Cooldown() : weak< Cooldown_Record >;
	public import function CooldownHandle() : Cooldown_Record;
	public import function DeviceHackCategory() : weak< DeviceHackCategory_Record >;
	public import function DeviceHackCategoryHandle() : DeviceHackCategory_Record;
	public import function HackTier() : weak< DeviceHackTier_Record >;
	public import function HackTierHandle() : DeviceHackTier_Record;
	public import function ActivationTime( out outList : array< weak< StatModifier_Record > > );
	public import function GetActivationTimeCount() : Int32;
	public import function GetActivationTimeItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetActivationTimeItemHandle( index : Int32 ) : StatModifier_Record;
	public import function ActivationTimeContains( item : weak< StatModifier_Record > ) : Bool;
	public import function InterruptionPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetInterruptionPrereqsCount() : Int32;
	public import function GetInterruptionPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetInterruptionPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function InterruptionPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function InstigatorPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetInstigatorPrereqsCount() : Int32;
	public import function GetInstigatorPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetInstigatorPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function InstigatorPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function InstigatorActivePrereqs( out outList : array< weak< ObjectActionPrereq_Record > > );
	public import function GetInstigatorActivePrereqsCount() : Int32;
	public import function GetInstigatorActivePrereqsItem( index : Int32 ) : weak< ObjectActionPrereq_Record >;
	public import function GetInstigatorActivePrereqsItemHandle( index : Int32 ) : ObjectActionPrereq_Record;
	public import function InstigatorActivePrereqsContains( item : weak< ObjectActionPrereq_Record > ) : Bool;
	public import function Rewards( out outList : array< weak< RewardBase_Record > > );
	public import function GetRewardsCount() : Int32;
	public import function GetRewardsItem( index : Int32 ) : weak< RewardBase_Record >;
	public import function GetRewardsItemHandle( index : Int32 ) : RewardBase_Record;
	public import function RewardsContains( item : weak< RewardBase_Record > ) : Bool;
	public import function TargetActivePrereqs( out outList : array< weak< ObjectActionPrereq_Record > > );
	public import function GetTargetActivePrereqsCount() : Int32;
	public import function GetTargetActivePrereqsItem( index : Int32 ) : weak< ObjectActionPrereq_Record >;
	public import function GetTargetActivePrereqsItemHandle( index : Int32 ) : ObjectActionPrereq_Record;
	public import function TargetActivePrereqsContains( item : weak< ObjectActionPrereq_Record > ) : Bool;
	public import function StartEffects( out outList : array< weak< ObjectActionEffect_Record > > );
	public import function GetStartEffectsCount() : Int32;
	public import function GetStartEffectsItem( index : Int32 ) : weak< ObjectActionEffect_Record >;
	public import function GetStartEffectsItemHandle( index : Int32 ) : ObjectActionEffect_Record;
	public import function StartEffectsContains( item : weak< ObjectActionEffect_Record > ) : Bool;
	public import function TargetPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetTargetPrereqsCount() : Int32;
	public import function GetTargetPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetTargetPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function TargetPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function DurationTime( out outList : array< weak< StatModifier_Record > > );
	public import function GetDurationTimeCount() : Int32;
	public import function GetDurationTimeItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetDurationTimeItemHandle( index : Int32 ) : StatModifier_Record;
	public import function DurationTimeContains( item : weak< StatModifier_Record > ) : Bool;
	public import function CompletionEffects( out outList : array< weak< ObjectActionEffect_Record > > );
	public import function GetCompletionEffectsCount() : Int32;
	public import function GetCompletionEffectsItem( index : Int32 ) : weak< ObjectActionEffect_Record >;
	public import function GetCompletionEffectsItemHandle( index : Int32 ) : ObjectActionEffect_Record;
	public import function CompletionEffectsContains( item : weak< ObjectActionEffect_Record > ) : Bool;
	public import function Costs( out outList : array< weak< ObjectActionCost_Record > > );
	public import function GetCostsCount() : Int32;
	public import function GetCostsItem( index : Int32 ) : weak< ObjectActionCost_Record >;
	public import function GetCostsItemHandle( index : Int32 ) : ObjectActionCost_Record;
	public import function CostsContains( item : weak< ObjectActionCost_Record > ) : Bool;
	public import function InteractionLayer() : CName;
	public import function ActionName() : CName;
	public import function Priority() : Float;
}

importonly class ObjectActionCost_Record extends TweakDBRecord
{
	public import function CostMods( out outList : array< weak< StatModifier_Record > > );
	public import function GetCostModsCount() : Int32;
	public import function GetCostModsItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetCostModsItemHandle( index : Int32 ) : StatModifier_Record;
	public import function CostModsContains( item : weak< StatModifier_Record > ) : Bool;
}

importonly class ObjectActionEffect_Record extends TweakDBRecord
{
	public import function EffectorToTrigger() : weak< Effector_Record >;
	public import function EffectorToTriggerHandle() : Effector_Record;
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function Recipient() : weak< ObjectActionReference_Record >;
	public import function RecipientHandle() : ObjectActionReference_Record;
}

importonly class ObjectActionGameplayCategory_Record extends ScannableData_Record
{
}

importonly class ObjectActionPrereq_Record extends TweakDBRecord
{
	public import function FailureExplanation() : String;
	public import function FailureConditionPrereq( out outList : array< weak< IPrereq_Record > > );
	public import function GetFailureConditionPrereqCount() : Int32;
	public import function GetFailureConditionPrereqItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetFailureConditionPrereqItemHandle( index : Int32 ) : IPrereq_Record;
	public import function FailureConditionPrereqContains( item : weak< IPrereq_Record > ) : Bool;
}

importonly class ObjectActionReference_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataObjectActionReference;
}

importonly class ObjectActionType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataObjectActionType;
}

importonly class OffMeshLinkTag_Record extends TweakDBRecord
{
	public import function Prerequisites( out outList : array< weak< IPrereq_Record > > );
	public import function GetPrerequisitesCount() : Int32;
	public import function GetPrerequisitesItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetPrerequisitesItemHandle( index : Int32 ) : IPrereq_Record;
	public import function PrerequisitesContains( item : weak< IPrereq_Record > ) : Bool;
	public import function Tag() : CName;
	public import function IsAllowed() : Bool;
}

importonly class Output_Record extends TweakDBRecord
{
	public import function OutputName() : String;
	public import function Priority() : Int32;
	public import function AIPriority() : Float;
	public import function Type() : gamedataOutput;
}

importonly class OverrideRangedAttackPackageEffector_Record extends Effector_Record
{
	public import function AttackPackage() : weak< RangedAttackPackage_Record >;
	public import function AttackPackageHandle() : RangedAttackPackage_Record;
}

importonly class OwnerAngleCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function MinAngle() : Float;
	public import function MaxAngle() : Float;
}

importonly class OwnerDistanceCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function OwnerMaxDistance() : Float;
	public import function DistanceToOwnerMultiplier() : Float;
	public import function OwnerPreferredDistance() : Float;
	public import function OwnerMinDistance() : Float;
}

importonly class OwnerThreatCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function OwnerThreatCoverAngle() : Float;
}

importonly class ParentAttachmentType_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Type() : gamedataParentAttachmentType;
}

importonly class ParticleDamage_Record extends TweakDBRecord
{
	public import function Attack() : weak< Attack_Record >;
	public import function AttackHandle() : Attack_Record;
	public import function ParticlePath() : ResRef;
	public import function Cooldown() : Float;
}

importonly class PassiveProficiencyBonus_Record extends TweakDBRecord
{
	public import function EffectorToTrigger() : weak< Effector_Record >;
	public import function EffectorToTriggerHandle() : Effector_Record;
	public import function StatGroup() : weak< StatModifierGroup_Record >;
	public import function StatGroupHandle() : StatModifierGroup_Record;
	public import function UiData() : weak< PassiveProficiencyBonusUIData_Record >;
	public import function UiDataHandle() : PassiveProficiencyBonusUIData_Record;
}

importonly class PassiveProficiencyBonusUIData_Record extends TweakDBRecord
{
	public import function IntValues() : array< Int32 >;
	public import function GetIntValuesCount() : Int32;
	public import function GetIntValuesItem( index : Int32 ) : Int32;
	public import function IntValuesContains( item : Int32 ) : Bool;
	public import function FloatValues() : array< Float >;
	public import function GetFloatValuesCount() : Int32;
	public import function GetFloatValuesItem( index : Int32 ) : Float;
	public import function FloatValuesContains( item : Float ) : Bool;
	public import function Stats( out outList : array< weak< Stat_Record > > );
	public import function GetStatsCount() : Int32;
	public import function GetStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function StatsContains( item : weak< Stat_Record > ) : Bool;
	public import function Loc_name_key() : CName;
	public import function Loc_desc_key() : CName;
}

importonly class PathLengthCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function MaximumRatio() : Float;
	public import function MinPathLengthToPerform() : Float;
	public import function Multiplier() : Float;
	public import function UseFriendlyTargetAsStart() : Bool;
	public import function DoorInvalidatesPath() : Bool;
}

importonly class PathSecurityCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function ThreatHalfSightAngle() : Float;
	public import function PathSampleDist() : Float;
	public import function Multiplier() : Float;
	public import function ThreatSightRange() : Float;
}

importonly class Perk_Record extends TweakDBRecord
{
	public import function DisplayName() : String;
	public import function Loc_name_key() : String;
	public import function EnumComment() : String;
	public import function Loc_desc_key() : String;
	public import function PerkIcon() : weak< UIIcon_Record >;
	public import function PerkIconHandle() : UIIcon_Record;
	public import function Utility() : weak< PerkUtility_Record >;
	public import function UtilityHandle() : PerkUtility_Record;
	public import function Levels( out outList : array< weak< PerkLevelData_Record > > );
	public import function GetLevelsCount() : Int32;
	public import function GetLevelsItem( index : Int32 ) : weak< PerkLevelData_Record >;
	public import function GetLevelsItemHandle( index : Int32 ) : PerkLevelData_Record;
	public import function LevelsContains( item : weak< PerkLevelData_Record > ) : Bool;
	public import function EnumName() : CName;
	public import function IconPath() : CName;
	public import function BinkPath() : ResRef;
	public import function Type() : gamedataPerkType;
}

importonly class PerkArea_Record extends TweakDBRecord
{
	public import function DisplayName() : String;
	public import function Loc_name_key() : String;
	public import function EnumComment() : String;
	public import function Loc_desc_key() : String;
	public import function Requirement() : weak< IPrereq_Record >;
	public import function RequirementHandle() : IPrereq_Record;
	public import function Curve() : weak< Curve_Record >;
	public import function CurveHandle() : Curve_Record;
	public import function Proficiency() : weak< Proficiency_Record >;
	public import function ProficiencyHandle() : Proficiency_Record;
	public import function MasteryLevel() : weak< StatPrereq_Record >;
	public import function MasteryLevelHandle() : StatPrereq_Record;
	public import function Perks( out outList : array< weak< Perk_Record > > );
	public import function GetPerksCount() : Int32;
	public import function GetPerksItem( index : Int32 ) : weak< Perk_Record >;
	public import function GetPerksItemHandle( index : Int32 ) : Perk_Record;
	public import function PerksContains( item : weak< Perk_Record > ) : Bool;
	public import function EnumName() : CName;
	public import function MinLevel() : Int32;
	public import function MaxLevel() : Int32;
	public import function Type() : gamedataPerkArea;
}

importonly class PerkLevelData_Record extends TweakDBRecord
{
	public import function Loc_name_key() : String;
	public import function Loc_desc_key() : String;
	public import function DataPackage() : weak< GameplayLogicPackage_Record >;
	public import function DataPackageHandle() : GameplayLogicPackage_Record;
	public import function UiData() : weak< PerkLevelUIData_Record >;
	public import function UiDataHandle() : PerkLevelUIData_Record;
}

importonly class PerkLevelUIData_Record extends TweakDBRecord
{
	public import function IntValues() : array< Int32 >;
	public import function GetIntValuesCount() : Int32;
	public import function GetIntValuesItem( index : Int32 ) : Int32;
	public import function IntValuesContains( item : Int32 ) : Bool;
	public import function FloatValues() : array< Float >;
	public import function GetFloatValuesCount() : Int32;
	public import function GetFloatValuesItem( index : Int32 ) : Float;
	public import function FloatValuesContains( item : Float ) : Bool;
	public import function NameValues() : array< CName >;
	public import function GetNameValuesCount() : Int32;
	public import function GetNameValuesItem( index : Int32 ) : CName;
	public import function NameValuesContains( item : CName ) : Bool;
}

importonly class PerkPrereq_Record extends IPrereq_Record
{
	public import function Perk() : String;
}

importonly class PerkUtility_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function UtilityType() : gamedataPerkUtility;
}

importonly class PerkWeaponGroup_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataPerkWeaponGroupType;
}

importonly class PersistentLootTable_Record extends LootTable_Record
{
}

importonly class PhotoModeBackground_Record extends PhotoModeItem_Record
{
	public import function TextureName() : ResRef;
}

importonly class PhotoModeEffect_Record extends PhotoModeItem_Record
{
	public import function LutPath() : CName;
	public import function HdrLutPath() : CName;
}

importonly class PhotoModeFace_Record extends PhotoModeItem_Record
{
	public import function FaceId() : Int32;
}

importonly class PhotoModeFrame_Record extends PhotoModeItem_Record
{
	public import function ImagePartsNames() : array< CName >;
	public import function GetImagePartsNamesCount() : Int32;
	public import function GetImagePartsNamesItem( index : Int32 ) : CName;
	public import function ImagePartsNamesContains( item : CName ) : Bool;
	public import function Color() : array< Int32 >;
	public import function GetColorCount() : Int32;
	public import function GetColorItem( index : Int32 ) : Int32;
	public import function ColorContains( item : Int32 ) : Bool;
	public import function AtlasName() : ResRef;
	public import function LibraryItemName() : CName;
	public import function FlipVertical() : Bool;
	public import function FlipHorizontal() : Bool;
}

importonly class PhotoModeItem_Record extends TweakDBRecord
{
	public import function DisplayName() : CName;
	public import function Locked() : Bool;
}

importonly class PhotoModePose_Record extends PhotoModeItem_Record
{
	public import function DisableLookAtForGarmentTags() : array< CName >;
	public import function GetDisableLookAtForGarmentTagsCount() : Int32;
	public import function GetDisableLookAtForGarmentTagsItem( index : Int32 ) : CName;
	public import function DisableLookAtForGarmentTagsContains( item : CName ) : Bool;
	public import function FilterOutForGarmentTags() : array< CName >;
	public import function GetFilterOutForGarmentTagsCount() : Int32;
	public import function GetFilterOutForGarmentTagsItem( index : Int32 ) : CName;
	public import function FilterOutForGarmentTagsContains( item : CName ) : Bool;
	public import function AcceptedWeaponConfig() : CName;
	public import function PoseStateConfig() : CName;
	public import function Category() : CName;
	public import function LookAtPreset() : CName;
	public import function AnimationName() : CName;
	public import function Rotation() : Vector3;
	public import function PositionOffset() : Vector3;
	public import function AnimationTime() : Float;
	public import function PoseSize() : Float;
	public import function AllowMoveUpDown() : Bool;
}

importonly class PhotoModePoseCategory_Record extends TweakDBRecord
{
	public import function CategoryName() : CName;
	public import function DisplayName() : CName;
}

importonly class PhotoModeSticker_Record extends PhotoModeItem_Record
{
	public import function ImagePartName() : CName;
	public import function AtlasName() : ResRef;
}

importonly class Pierce_Record extends ProjectileCollision_Record
{
}

importonly class Ping_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function WorldIconName() : CName;
	public import function MinimapIconName() : CName;
	public import function VoTriggerName() : CName;
	public import function EnumName() : CName;
	public import function MaxCount() : Int32;
	public import function LifeSpan() : Float;
	public import function Type() : gamedataPingType;
}

importonly class PlayerBuild_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function CaptionIcon() : weak< ChoiceCaptionIconPart_Record >;
	public import function CaptionIconHandle() : ChoiceCaptionIconPart_Record;
	public import function Proficiencies( out outList : array< weak< Proficiency_Record > > );
	public import function GetProficienciesCount() : Int32;
	public import function GetProficienciesItem( index : Int32 ) : weak< Proficiency_Record >;
	public import function GetProficienciesItemHandle( index : Int32 ) : Proficiency_Record;
	public import function ProficienciesContains( item : weak< Proficiency_Record > ) : Bool;
	public import function DisplayName() : CName;
	public import function EnumName() : CName;
	public import function Type() : gamedataPlayerBuild;
}

importonly class PlayerIsNewPerkBoughtPrereq_Record extends IPrereq_Record
{
	public import function PerkType() : String;
	public import function Level() : Int32;
	public import function Invert() : Bool;
}

importonly class PlayerPossesion_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataPlayerPossesion;
}

importonly class PoolValueModifier_Record extends TweakDBRecord
{
	public import function StartDelay() : Float;
	public import function ValuePerSec() : Float;
	public import function RangeBegin() : Float;
	public import function RangeEnd() : Float;
	public import function Enabled() : Bool;
	public import function UsingPointValues() : Bool;
	public import function DelayOnChange() : Bool;
}

importonly class Prereq_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function DevNotes() : String;
	public import function Checks( out outList : array< weak< PrereqCheck_Record > > );
	public import function GetChecksCount() : Int32;
	public import function GetChecksItem( index : Int32 ) : weak< PrereqCheck_Record >;
	public import function GetChecksItemHandle( index : Int32 ) : PrereqCheck_Record;
	public import function ChecksContains( item : weak< PrereqCheck_Record > ) : Bool;
	public import function AndValues() : Bool;
}

importonly class PrereqCheck_Record extends TweakDBRecord
{
	public import function PrereqType() : String;
	public import function ComparisonType() : String;
	public import function ContextObject() : String;
	public import function ValueToCompare() : Float;
}

importonly class PresetMapper_Record extends TweakDBRecord
{
	public import function MappingName() : String;
	public import function Preset() : weak< ReactionPreset_Record >;
	public import function PresetHandle() : ReactionPreset_Record;
}

importonly class PreventionAttackTypeData_Record extends TweakDBRecord
{
	public import function Explosion() : Float;
	public import function Hack() : Float;
	public import function Ranged() : Float;
	public import function Melee() : Float;
	public import function Indirect() : Float;
	public import function Kill() : Float;
}

importonly class PreventionFallbackUnitData_Record extends TweakDBRecord
{
	public import function CharacterRecord() : weak< Character_Record >;
	public import function CharacterRecordHandle() : Character_Record;
	public import function MinSpawnRange() : Float;
	public import function UnitsCount() : Int32;
}

importonly class PreventionHeatData_Record extends TweakDBRecord
{
	public import function AvRecord() : weak< Vehicle_Record >;
	public import function AvRecordHandle() : Vehicle_Record;
	public import function FallbackUnitData() : weak< PreventionFallbackUnitData_Record >;
	public import function FallbackUnitDataHandle() : PreventionFallbackUnitData_Record;
	public import function VehicleRecordPool( out outList : array< weak< PreventionVehiclePoolData_Record > > );
	public import function GetVehicleRecordPoolCount() : Int32;
	public import function GetVehicleRecordPoolItem( index : Int32 ) : weak< PreventionVehiclePoolData_Record >;
	public import function GetVehicleRecordPoolItemHandle( index : Int32 ) : PreventionVehiclePoolData_Record;
	public import function VehicleRecordPoolContains( item : weak< PreventionVehiclePoolData_Record > ) : Bool;
	public import function UnitRecordsPool( out outList : array< weak< PreventionUnitPoolData_Record > > );
	public import function GetUnitRecordsPoolCount() : Int32;
	public import function GetUnitRecordsPoolItem( index : Int32 ) : weak< PreventionUnitPoolData_Record >;
	public import function GetUnitRecordsPoolItemHandle( index : Int32 ) : PreventionUnitPoolData_Record;
	public import function UnitRecordsPoolContains( item : weak< PreventionUnitPoolData_Record > ) : Bool;
	public import function QuestVehicleRecordPool( out outList : array< weak< PreventionVehiclePoolData_Record > > );
	public import function GetQuestVehicleRecordPoolCount() : Int32;
	public import function GetQuestVehicleRecordPoolItem( index : Int32 ) : weak< PreventionVehiclePoolData_Record >;
	public import function GetQuestVehicleRecordPoolItemHandle( index : Int32 ) : PreventionVehiclePoolData_Record;
	public import function QuestVehicleRecordPoolContains( item : weak< PreventionVehiclePoolData_Record > ) : Bool;
	public import function VehicleSpawnDistanceRange() : Vector2;
	public import function SpawnRange() : Vector2;
	public import function AvSpawnDistanceRange() : Vector2;
	public import function VehicleSpawnAngleRange() : Vector2;
	public import function AvSpawnAngleRange() : Vector2;
	public import function RoadblockadeSpawnRange() : Vector2;
	public import function UnitsCount() : Int32;
	public import function SpawnInterval() : Float;
	public import function VehicleCount() : Int32;
	public import function CrimeScoreMultiplier() : Float;
}

importonly class PreventionHeatDataMatrix_Record extends TweakDBRecord
{
	public import function Heat1() : weak< PreventionHeatTable_Record >;
	public import function Heat1Handle() : PreventionHeatTable_Record;
	public import function Heat3() : weak< PreventionHeatTable_Record >;
	public import function Heat3Handle() : PreventionHeatTable_Record;
	public import function Heat0() : weak< PreventionHeatTable_Record >;
	public import function Heat0Handle() : PreventionHeatTable_Record;
	public import function Heat4() : weak< PreventionHeatTable_Record >;
	public import function Heat4Handle() : PreventionHeatTable_Record;
	public import function Heat2() : weak< PreventionHeatTable_Record >;
	public import function Heat2Handle() : PreventionHeatTable_Record;
	public import function Recon() : weak< PreventionHeatTable_Record >;
	public import function ReconHandle() : PreventionHeatTable_Record;
	public import function Heat5() : weak< PreventionHeatTable_Record >;
	public import function Heat5Handle() : PreventionHeatTable_Record;
	public import function MinimapData() : weak< PreventionMinimapData_Record >;
	public import function MinimapDataHandle() : PreventionMinimapData_Record;
}

importonly class PreventionHeatTable_Record extends TweakDBRecord
{
	public import function DisplayName() : String;
	public import function Strategy0() : weak< StrategyData_Record >;
	public import function Strategy0Handle() : StrategyData_Record;
	public import function Strategy1() : weak< StrategyData_Record >;
	public import function Strategy1Handle() : StrategyData_Record;
	public import function Strategy2() : weak< StrategyData_Record >;
	public import function Strategy2Handle() : StrategyData_Record;
	public import function Strategy3() : weak< StrategyData_Record >;
	public import function Strategy3Handle() : StrategyData_Record;
	public import function Strategy4() : weak< StrategyData_Record >;
	public import function Strategy4Handle() : StrategyData_Record;
	public import function Strategy5() : weak< StrategyData_Record >;
	public import function Strategy5Handle() : StrategyData_Record;
	public import function Strategy6() : weak< StrategyData_Record >;
	public import function Strategy6Handle() : StrategyData_Record;
	public import function Strategy7() : weak< StrategyData_Record >;
	public import function Strategy7Handle() : StrategyData_Record;
	public import function AvSpawnRange() : Vector2;
	public import function HeatExplosionPolice() : Float;
	public import function RoadblockT2TicketAmount() : Int32;
	public import function HeatKillMaxTac() : Float;
	public import function VehicleSpawnCooldown() : Float;
	public import function AvMaxDistanceForNewRequest() : Float;
	public import function HeatShootMaxTac() : Float;
	public import function StateBlinkingStarTime() : Float;
	public import function RoadblockT1TicketAmount() : Int32;
	public import function CrimeAreaRadius() : Float;
	public import function AvMinDistToSpawnedAV() : Float;
	public import function SpawnedEngagedCars() : Int32;
	public import function CivVehicleCrimeScoreMultiplier() : Float;
	public import function HeatKillCiv() : Float;
	public import function HeatQuickHackPolice() : Float;
	public import function RoadblockT3Cooldown() : Float;
	public import function HeatRangeAttackCiv() : Float;
	public import function HeatCrimeScoreResetTime() : Float;
	public import function MaxUnitFallbackCount() : Int32;
	public import function HeatHijackVehicle() : Float;
	public import function MaxUnitCount() : Int32;
	public import function HeatExplosionCiv() : Float;
	public import function HeatRangeAttackPolice() : Float;
	public import function RoadblockT2Cooldown() : Float;
	public import function HeatMeleAttackCiv() : Float;
	public import function SpawnedSupportCars() : Int32;
	public import function AvCooldown() : Float;
	public import function VehicleTicketCooldown() : Float;
	public import function FallbackVehicleSpawnFailedAttempts() : Int32;
	public import function PoliceVehicleCrimeScoreMultiplier() : Float;
	public import function AvSpawnPointsPerRequest() : Int32;
	public import function StateBufferTimer() : Float;
	public import function RoadblockT3TicketAmount() : Int32;
	public import function HeatThresholdCapacity() : Float;
	public import function HeatKillPolice() : Float;
	public import function HeatQuickHackCiv() : Float;
	public import function HeatStealPoliceVehicle() : Float;
	public import function RoadblockT1Cooldown() : Float;
	public import function HeatMeleAttackPolice() : Float;
	public import function StateGreyStarTime() : Float;
	public import function VehicleTicketsAmount() : Int32;
	public import function FallbackMaxDistanceToRoad() : Float;
	public import function FallbackMaxHeightDifference() : Float;
	public import function FallbackMaxDistanceForHeight() : Float;
	public import function IdleStateTransitionDelay() : Float;
	public import function IntroRadioStateTransitionDelay() : Float;
	public import function HackLoopTimeToHack() : Float;
	public import function HackLoopTimeToHack2() : Float;
	public import function HackLoopTimeToHack3() : Float;
	public import function HackLoopHackDuration() : Float;
	public import function HackLoopDurationInGoodSpot() : Float;
	public import function HackLoopPlayerVehicleMaxtacDistance() : Float;
	public import function TimeBetweenAVSpawnsAfterEncounter() : Float;
	public import function IsVehicleHackingLoopEnabled() : Bool;
}

importonly class PreventionMinimapData_Record extends TweakDBRecord
{
	public import function MinRadius() : Float;
	public import function MaxRadius() : Float;
	public import function MinSpeed() : Float;
	public import function MaxSpeed() : Float;
}

importonly class PreventionUnitPoolData_Record extends TweakDBRecord
{
	public import function CharacterRecord() : weak< Character_Record >;
	public import function CharacterRecordHandle() : Character_Record;
	public import function Weight() : Float;
}

importonly class PreventionVehiclePoolData_Record extends TweakDBRecord
{
	public import function VehicleRecord() : weak< Vehicle_Record >;
	public import function VehicleRecordHandle() : Vehicle_Record;
	public import function Weight() : Float;
}

importonly class Proficiency_Record extends TweakDBRecord
{
	public import function Loc_desc_key() : String;
	public import function Loc_name_key() : String;
	public import function EnumComment() : String;
	public import function DisplayName() : String;
	public import function Trait() : weak< Trait_Record >;
	public import function TraitHandle() : Trait_Record;
	public import function TiedAttribute() : weak< Stat_Record >;
	public import function TiedAttributeHandle() : Stat_Record;
	public import function PerkAreas( out outList : array< weak< PerkArea_Record > > );
	public import function GetPerkAreasCount() : Int32;
	public import function GetPerkAreasItem( index : Int32 ) : weak< PerkArea_Record >;
	public import function GetPerkAreasItemHandle( index : Int32 ) : PerkArea_Record;
	public import function PerkAreasContains( item : weak< PerkArea_Record > ) : Bool;
	public import function PassiveBonuses( out outList : array< weak< PassiveProficiencyBonus_Record > > );
	public import function GetPassiveBonusesCount() : Int32;
	public import function GetPassiveBonusesItem( index : Int32 ) : weak< PassiveProficiencyBonus_Record >;
	public import function GetPassiveBonusesItemHandle( index : Int32 ) : PassiveProficiencyBonus_Record;
	public import function PassiveBonusesContains( item : weak< PassiveProficiencyBonus_Record > ) : Bool;
	public import function Packages( out outList : array< weak< GameplayLogicPackage_Record > > );
	public import function GetPackagesCount() : Int32;
	public import function GetPackagesItem( index : Int32 ) : weak< GameplayLogicPackage_Record >;
	public import function GetPackagesItemHandle( index : Int32 ) : GameplayLogicPackage_Record;
	public import function PackagesContains( item : weak< GameplayLogicPackage_Record > ) : Bool;
	public import function EnumName() : CName;
	public import function CurveSetName() : CName;
	public import function CurveName() : CName;
	public import function IconPath() : CName;
	public import function MaxLevel() : Int32;
	public import function MinLevel() : Int32;
	public import function Type() : gamedataProficiencyType;
}

importonly class Program_Record extends TweakDBRecord
{
	public import function Program() : weak< ObjectAction_Record >;
	public import function ProgramHandle() : ObjectAction_Record;
	public import function CharactersChain() : array< Int32 >;
	public import function GetCharactersChainCount() : Int32;
	public import function GetCharactersChainItem( index : Int32 ) : Int32;
	public import function CharactersChainContains( item : Int32 ) : Bool;
	public import function ProgramName() : CName;
}

importonly class ProgressionBuild_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function InventorySet() : weak< InventoryItemSet_Record >;
	public import function InventorySetHandle() : InventoryItemSet_Record;
	public import function ProficiencySet() : weak< BuildProficiencySet_Record >;
	public import function ProficiencySetHandle() : BuildProficiencySet_Record;
	public import function AttributeSet() : weak< BuildAttributeSet_Record >;
	public import function AttributeSetHandle() : BuildAttributeSet_Record;
	public import function LifePath() : weak< LifePath_Record >;
	public import function LifePathHandle() : LifePath_Record;
	public import function PerkSet() : weak< BuildPerkSet_Record >;
	public import function PerkSetHandle() : BuildPerkSet_Record;
	public import function CyberwareSet() : weak< BuildCyberwareSet_Record >;
	public import function CyberwareSetHandle() : BuildCyberwareSet_Record;
	public import function EquipmentSet() : weak< BuildEquipmentSet_Record >;
	public import function EquipmentSetHandle() : BuildEquipmentSet_Record;
	public import function CraftBook() : weak< Craftable_Record >;
	public import function CraftBookHandle() : Craftable_Record;
	public import function PerkSets( out outList : array< weak< BuildPerkSet_Record > > );
	public import function GetPerkSetsCount() : Int32;
	public import function GetPerkSetsItem( index : Int32 ) : weak< BuildPerkSet_Record >;
	public import function GetPerkSetsItemHandle( index : Int32 ) : BuildPerkSet_Record;
	public import function PerkSetsContains( item : weak< BuildPerkSet_Record > ) : Bool;
	public import function StartingItems( out outList : array< weak< InventoryItem_Record > > );
	public import function GetStartingItemsCount() : Int32;
	public import function GetStartingItemsItem( index : Int32 ) : weak< InventoryItem_Record >;
	public import function GetStartingItemsItemHandle( index : Int32 ) : InventoryItem_Record;
	public import function StartingItemsContains( item : weak< InventoryItem_Record > ) : Bool;
	public import function StartingNewPerks( out outList : array< weak< BuildNewPerk_Record > > );
	public import function GetStartingNewPerksCount() : Int32;
	public import function GetStartingNewPerksItem( index : Int32 ) : weak< BuildNewPerk_Record >;
	public import function GetStartingNewPerksItemHandle( index : Int32 ) : BuildNewPerk_Record;
	public import function StartingNewPerksContains( item : weak< BuildNewPerk_Record > ) : Bool;
	public import function StartingAttributes( out outList : array< weak< BuildAttribute_Record > > );
	public import function GetStartingAttributesCount() : Int32;
	public import function GetStartingAttributesItem( index : Int32 ) : weak< BuildAttribute_Record >;
	public import function GetStartingAttributesItemHandle( index : Int32 ) : BuildAttribute_Record;
	public import function StartingAttributesContains( item : weak< BuildAttribute_Record > ) : Bool;
	public import function StartingEquipment( out outList : array< weak< BuildEquipment_Record > > );
	public import function GetStartingEquipmentCount() : Int32;
	public import function GetStartingEquipmentItem( index : Int32 ) : weak< BuildEquipment_Record >;
	public import function GetStartingEquipmentItemHandle( index : Int32 ) : BuildEquipment_Record;
	public import function StartingEquipmentContains( item : weak< BuildEquipment_Record > ) : Bool;
	public import function StartingPrograms( out outList : array< weak< BuildProgram_Record > > );
	public import function GetStartingProgramsCount() : Int32;
	public import function GetStartingProgramsItem( index : Int32 ) : weak< BuildProgram_Record >;
	public import function GetStartingProgramsItemHandle( index : Int32 ) : BuildProgram_Record;
	public import function StartingProgramsContains( item : weak< BuildProgram_Record > ) : Bool;
	public import function StartingCyberware( out outList : array< weak< BuildCyberware_Record > > );
	public import function GetStartingCyberwareCount() : Int32;
	public import function GetStartingCyberwareItem( index : Int32 ) : weak< BuildCyberware_Record >;
	public import function GetStartingCyberwareItemHandle( index : Int32 ) : BuildCyberware_Record;
	public import function StartingCyberwareContains( item : weak< BuildCyberware_Record > ) : Bool;
	public import function StartingPerks( out outList : array< weak< BuildPerk_Record > > );
	public import function GetStartingPerksCount() : Int32;
	public import function GetStartingPerksItem( index : Int32 ) : weak< BuildPerk_Record >;
	public import function GetStartingPerksItemHandle( index : Int32 ) : BuildPerk_Record;
	public import function StartingPerksContains( item : weak< BuildPerk_Record > ) : Bool;
	public import function StartingProficiencies( out outList : array< weak< BuildProficiency_Record > > );
	public import function GetStartingProficienciesCount() : Int32;
	public import function GetStartingProficienciesItem( index : Int32 ) : weak< BuildProficiency_Record >;
	public import function GetStartingProficienciesItemHandle( index : Int32 ) : BuildProficiency_Record;
	public import function StartingProficienciesContains( item : weak< BuildProficiency_Record > ) : Bool;
	public import function InventoryLayout( out outList : array< weak< CPOItemCategoryBase_Record > > );
	public import function GetInventoryLayoutCount() : Int32;
	public import function GetInventoryLayoutItem( index : Int32 ) : weak< CPOItemCategoryBase_Record >;
	public import function GetInventoryLayoutItemHandle( index : Int32 ) : CPOItemCategoryBase_Record;
	public import function InventoryLayoutContains( item : weak< CPOItemCategoryBase_Record > ) : Bool;
	public import function EnumName() : CName;
	public import function RandomizeClothing() : Bool;
	public import function Type() : gamedataBuildType;
}

importonly class ProjectileCollision_Record extends TweakDBRecord
{
	public import function Type() : weak< ProjectileOnCollisionAction_Record >;
	public import function TypeHandle() : ProjectileOnCollisionAction_Record;
	public import function EnergyLossFactor() : Float;
	public import function CanStopAndStickOnHardSurfaces() : Bool;
}

importonly class ProjectileLaunch_Record extends TweakDBRecord
{
	public import function Type() : weak< ProjectileLaunchMode_Record >;
	public import function TypeHandle() : ProjectileLaunchMode_Record;
	public import function ApplyAdditiveProjectileSpiraling() : Bool;
	public import function CanTrackDevices() : Bool;
}

importonly class ProjectileLaunchMode_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataProjectileLaunchMode;
}

importonly class ProjectileOnCollisionAction_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataProjectileOnCollisionAction;
}

importonly class Prop_Record extends SpawnableObject_Record
{
	public import function FriendlyName() : String;
}

importonly class PropagateStatusEffectInAreaEffector_Record extends Effector_Record
{
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function ApplicationTarget() : CName;
	public import function Range() : Float;
	public import function Duration() : Float;
	public import function PropagateToInstigator() : Bool;
}

importonly class PurchaseOffer_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function PreviewImage() : weak< JournalIcon_Record >;
	public import function PreviewImageHandle() : JournalIcon_Record;
	public import function Price() : weak< ValueAssignment_Record >;
	public import function PriceHandle() : ValueAssignment_Record;
}

importonly class Quality_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function Value() : Int32;
	public import function Type() : gamedataQuality;
}

importonly class Query_Record extends TweakDBRecord
{
	public import function RecordType() : CName;
}

importonly class QuestRestrictionMode_Record extends TweakDBRecord
{
	public import function InjectedActions() : array< CName >;
	public import function GetInjectedActionsCount() : Int32;
	public import function GetInjectedActionsItem( index : Int32 ) : CName;
	public import function InjectedActionsContains( item : CName ) : Bool;
}

importonly class QuestSystemSetup_Record extends TweakDBRecord
{
	public import function CustomTooltipActions() : array< String >;
	public import function GetCustomTooltipActionsCount() : Int32;
	public import function GetCustomTooltipActionsItem( index : Int32 ) : String;
	public import function CustomTooltipActionsContains( item : String ) : Bool;
	public import function ContentTokenMinimalCooldownWhenBlocking() : Float;
	public import function ContentTokenStackMaxSize() : Int32;
	public import function ContentTokenSpawnMaxCooldown() : Float;
	public import function ContentTokenSpawnMinCooldown() : Float;
}

importonly class RPGAction_Record extends TweakDBRecord
{
	public import function Reward() : weak< RewardBase_Record >;
	public import function RewardHandle() : RewardBase_Record;
	public import function Prereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetPrereqsCount() : Int32;
	public import function GetPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function PrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function ActionName() : CName;
}

importonly class RPGDataPackage_Record extends TweakDBRecord
{
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function StatModifierGroups( out outList : array< weak< StatModifierGroup_Record > > );
	public import function GetStatModifierGroupsCount() : Int32;
	public import function GetStatModifierGroupsItem( index : Int32 ) : weak< StatModifierGroup_Record >;
	public import function GetStatModifierGroupsItemHandle( index : Int32 ) : StatModifierGroup_Record;
	public import function StatModifierGroupsContains( item : weak< StatModifierGroup_Record > ) : Bool;
	public import function StatPools( out outList : array< weak< StatPool_Record > > );
	public import function GetStatPoolsCount() : Int32;
	public import function GetStatPoolsItem( index : Int32 ) : weak< StatPool_Record >;
	public import function GetStatPoolsItemHandle( index : Int32 ) : StatPool_Record;
	public import function StatPoolsContains( item : weak< StatPool_Record > ) : Bool;
	public import function Effectors( out outList : array< weak< Effector_Record > > );
	public import function GetEffectorsCount() : Int32;
	public import function GetEffectorsItem( index : Int32 ) : weak< Effector_Record >;
	public import function GetEffectorsItemHandle( index : Int32 ) : Effector_Record;
	public import function EffectorsContains( item : weak< Effector_Record > ) : Bool;
}

importonly class RaceCheckpoint_Record extends LCDScreen_Record
{
}

importonly class RacingMappin_Record extends TweakDBRecord
{
	public import function Title() : String;
	public import function Description() : String;
}

importonly class RadioStation_Record extends TweakDBRecord
{
	public import function DisplayName() : String;
	public import function Icon() : weak< UIIcon_Record >;
	public import function IconHandle() : UIIcon_Record;
	public import function Index() : Int32;
}

importonly class RandomNewsFeedBatch_Record extends TweakDBRecord
{
	public import function FeedList() : array< CName >;
	public import function GetFeedListCount() : Int32;
	public import function GetFeedListItem( index : Int32 ) : CName;
	public import function FeedListContains( item : CName ) : Bool;
}

importonly class RandomPassengerEntry_Record extends TweakDBRecord
{
	public import function ValidSlotNames() : array< CName >;
	public import function GetValidSlotNamesCount() : Int32;
	public import function GetValidSlotNamesItem( index : Int32 ) : CName;
	public import function ValidSlotNamesContains( item : CName ) : Bool;
	public import function CharacterRecords( out outList : array< weak< WeightedCharacter_Record > > );
	public import function GetCharacterRecordsCount() : Int32;
	public import function GetCharacterRecordsItem( index : Int32 ) : weak< WeightedCharacter_Record >;
	public import function GetCharacterRecordsItemHandle( index : Int32 ) : WeightedCharacter_Record;
	public import function CharacterRecordsContains( item : weak< WeightedCharacter_Record > ) : Bool;
	public import function Role() : CName;
	public import function Probability() : Float;
}

importonly class RandomRatioCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
}

importonly class RandomStatModifier_Record extends StatModifier_Record
{
	public import function Max() : Float;
	public import function Min() : Float;
	public import function UseControlledRandom() : Bool;
}

importonly class RandomVariant_Record extends TweakDBRecord
{
	public import function VariantPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetVariantPrereqsCount() : Int32;
	public import function GetVariantPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetVariantPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function VariantPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function StatModifierGroups( out outList : array< weak< StatModifierGroup_Record > > );
	public import function GetStatModifierGroupsCount() : Int32;
	public import function GetStatModifierGroupsItem( index : Int32 ) : weak< StatModifierGroup_Record >;
	public import function GetStatModifierGroupsItemHandle( index : Int32 ) : StatModifierGroup_Record;
	public import function StatModifierGroupsContains( item : weak< StatModifierGroup_Record > ) : Bool;
	public import function Weight() : Float;
}

importonly class RangedAttack_Record extends TweakDBRecord
{
	public import function PlayerAttack() : weak< Attack_Record >;
	public import function PlayerAttackHandle() : Attack_Record;
	public import function NPCAttack() : weak< Attack_Record >;
	public import function NPCAttackHandle() : Attack_Record;
	public import function SecondaryPlayerAttack() : weak< Attack_Record >;
	public import function SecondaryPlayerAttackHandle() : Attack_Record;
	public import function PlayerTimeDilated() : weak< Attack_Record >;
	public import function PlayerTimeDilatedHandle() : Attack_Record;
	public import function SecondaryPlayerTimeDilated() : weak< Attack_Record >;
	public import function SecondaryPlayerTimeDilatedHandle() : Attack_Record;
	public import function NPCTimeDilated() : weak< Attack_Projectile_Record >;
	public import function NPCTimeDilatedHandle() : Attack_Projectile_Record;
}

importonly class RangedAttackPackage_Record extends TweakDBRecord
{
	public import function DefaultFire() : weak< RangedAttack_Record >;
	public import function DefaultFireHandle() : RangedAttack_Record;
	public import function ChargeFire() : weak< RangedAttack_Record >;
	public import function ChargeFireHandle() : RangedAttack_Record;
}

importonly class ReactionLimit_Record extends TweakDBRecord
{
	public import function Name() : CName;
	public import function Limit() : Int32;
}

importonly class ReactionPreset_Record extends TweakDBRecord
{
	public import function ReactionGroup() : String;
	public import function EnumComment() : String;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function Rules( out outList : array< weak< Rule_Record > > );
	public import function GetRulesCount() : Int32;
	public import function GetRulesItem( index : Int32 ) : weak< Rule_Record >;
	public import function GetRulesItemHandle( index : Int32 ) : Rule_Record;
	public import function RulesContains( item : weak< Rule_Record > ) : Bool;
	public import function PresetMapper( out outList : array< weak< PresetMapper_Record > > );
	public import function GetPresetMapperCount() : Int32;
	public import function GetPresetMapperItem( index : Int32 ) : weak< PresetMapper_Record >;
	public import function GetPresetMapperItemHandle( index : Int32 ) : PresetMapper_Record;
	public import function PresetMapperContains( item : weak< PresetMapper_Record > ) : Bool;
	public import function EnumName() : CName;
	public import function FearThreshold() : Float;
	public import function AggressiveThreshold() : Float;
	public import function IsAggressive() : Bool;
	public import function Type() : gamedataReactionPresetType;
}

importonly class ReactionPresetCivilian_Record extends ReactionPreset_Record
{
}

importonly class ReactionPresetCorpo_Record extends ReactionPreset_Record
{
}

importonly class ReactionPresetGanger_Record extends ReactionPreset_Record
{
}

importonly class ReactionPresetMechanical_Record extends ReactionPreset_Record
{
}

importonly class ReactionPresetNoReaction_Record extends ReactionPreset_Record
{
}

importonly class ReactionPresetPolice_Record extends ReactionPreset_Record
{
}

importonly class RearWheelsFrictionModifier_Record extends DriveHelper_Record
{
	public import function MinLongSlipRatio() : Float;
	public import function MinLongFrictionCoef() : Float;
	public import function MinLatSlipRatio() : Float;
	public import function MaxLatSlipRatio() : Float;
	public import function MaxLongSlipRatio() : Float;
	public import function MinLatFrictionCoef() : Float;
	public import function MaxSpeed() : Float;
	public import function MaxHelperAcceleration() : Float;
}

importonly class RecipeElement_Record extends TweakDBRecord
{
	public import function Ingredient() : weak< Item_Record >;
	public import function IngredientHandle() : Item_Record;
	public import function Amount() : Int32;
}

importonly class RecipeItem_Record extends Item_Record
{
	public import function CraftableItems( out outList : array< weak< Item_Record > > );
	public import function GetCraftableItemsCount() : Int32;
	public import function GetCraftableItemsItem( index : Int32 ) : weak< Item_Record >;
	public import function GetCraftableItemsItemHandle( index : Int32 ) : Item_Record;
	public import function CraftableItemsContains( item : weak< Item_Record > ) : Bool;
}

importonly class Regular_Record extends ProjectileLaunch_Record
{
	public import function StartVelocity() : Float;
	public import function StartVelocityCharged() : Float;
}

importonly class RegularGDM_Record extends GrenadeDeliveryMethod_Record
{
}

importonly class RemoveAllModifiersEffector_Record extends Effector_Record
{
	public import function StatType() : weak< Stat_Record >;
	public import function StatTypeHandle() : Stat_Record;
	public import function ApplicationTarget() : CName;
}

importonly class RewardBase_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function ContentAssignment() : weak< ContentAssignment_Record >;
	public import function ContentAssignmentHandle() : ContentAssignment_Record;
	public import function Recipes( out outList : array< weak< Item_Record > > );
	public import function GetRecipesCount() : Int32;
	public import function GetRecipesItem( index : Int32 ) : weak< Item_Record >;
	public import function GetRecipesItemHandle( index : Int32 ) : Item_Record;
	public import function RecipesContains( item : weak< Item_Record > ) : Bool;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function CurrencyPackage( out outList : array< weak< CurrencyReward_Record > > );
	public import function GetCurrencyPackageCount() : Int32;
	public import function GetCurrencyPackageItem( index : Int32 ) : weak< CurrencyReward_Record >;
	public import function GetCurrencyPackageItemHandle( index : Int32 ) : CurrencyReward_Record;
	public import function CurrencyPackageContains( item : weak< CurrencyReward_Record > ) : Bool;
	public import function Experience( out outList : array< weak< XPPoints_Record > > );
	public import function GetExperienceCount() : Int32;
	public import function GetExperienceItem( index : Int32 ) : weak< XPPoints_Record >;
	public import function GetExperienceItemHandle( index : Int32 ) : XPPoints_Record;
	public import function ExperienceContains( item : weak< XPPoints_Record > ) : Bool;
	public import function Items( out outList : array< weak< InventoryItem_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< InventoryItem_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : InventoryItem_Record;
	public import function ItemsContains( item : weak< InventoryItem_Record > ) : Bool;
	public import function Achievement( out outList : array< weak< Achievement_Record > > );
	public import function GetAchievementCount() : Int32;
	public import function GetAchievementItem( index : Int32 ) : weak< Achievement_Record >;
	public import function GetAchievementItemHandle( index : Int32 ) : Achievement_Record;
	public import function AchievementContains( item : weak< Achievement_Record > ) : Bool;
	public import function PhotoModeItem( out outList : array< weak< PhotoModeItem_Record > > );
	public import function GetPhotoModeItemCount() : Int32;
	public import function GetPhotoModeItemItem( index : Int32 ) : weak< PhotoModeItem_Record >;
	public import function GetPhotoModeItemItemHandle( index : Int32 ) : PhotoModeItem_Record;
	public import function PhotoModeItemContains( item : weak< PhotoModeItem_Record > ) : Bool;
}

importonly class RewardBase_inline0_Record extends ConstantStatModifier_Record
{
}

importonly class RewardSet_Record extends TweakDBRecord
{
	public import function RewardItems( out outList : array< weak< Item_Record > > );
	public import function GetRewardItemsCount() : Int32;
	public import function GetRewardItemsItem( index : Int32 ) : weak< Item_Record >;
	public import function GetRewardItemsItemHandle( index : Int32 ) : Item_Record;
	public import function RewardItemsContains( item : weak< Item_Record > ) : Bool;
}

importonly class Rigs_Record extends TweakDBRecord
{
	public import function RigsResRefs() : array< ResRef >;
	public import function GetRigsResRefsCount() : Int32;
	public import function GetRigsResRefsItem( index : Int32 ) : ResRef;
}

importonly class RipperdocMappin_Record extends UIIcon_Record
{
	public import function LocalizedName() : String;
}

importonly class RoachRaceBackground_Record extends TweakDBRecord
{
	public import function LayerList( out outList : array< weak< ArcadeBackgroundLayer_Record > > );
	public import function GetLayerListCount() : Int32;
	public import function GetLayerListItem( index : Int32 ) : weak< ArcadeBackgroundLayer_Record >;
	public import function GetLayerListItemHandle( index : Int32 ) : ArcadeBackgroundLayer_Record;
	public import function LayerListContains( item : weak< ArcadeBackgroundLayer_Record > ) : Bool;
	public import function ObjectList( out outList : array< weak< RoachRaceBackgroundObject_Record > > );
	public import function GetObjectListCount() : Int32;
	public import function GetObjectListItem( index : Int32 ) : weak< RoachRaceBackgroundObject_Record >;
	public import function GetObjectListItemHandle( index : Int32 ) : RoachRaceBackgroundObject_Record;
	public import function ObjectListContains( item : weak< RoachRaceBackgroundObject_Record > ) : Bool;
	public import function StopSFX() : CName;
	public import function StartSFX() : CName;
	public import function IsSunAndMoonVisible() : Bool;
}

importonly class RoachRaceBackgroundObject_Record extends ArcadeObject_Record
{
	public import function Position() : Float;
	public import function Probability() : Float;
}

importonly class RoachRaceLevel_Record extends TweakDBRecord
{
	public import function Background() : weak< RoachRaceBackground_Record >;
	public import function BackgroundHandle() : RoachRaceBackground_Record;
	public import function ObstacleTexturePartMap( out outList : array< weak< RoachRaceObstacleTexturePartPair_Record > > );
	public import function GetObstacleTexturePartMapCount() : Int32;
	public import function GetObstacleTexturePartMapItem( index : Int32 ) : weak< RoachRaceObstacleTexturePartPair_Record >;
	public import function GetObstacleTexturePartMapItemHandle( index : Int32 ) : RoachRaceObstacleTexturePartPair_Record;
	public import function ObstacleTexturePartMapContains( item : weak< RoachRaceObstacleTexturePartPair_Record > ) : Bool;
	public import function ObstacleList( out outList : array< weak< RoachRaceObstacle_Record > > );
	public import function GetObstacleListCount() : Int32;
	public import function GetObstacleListItem( index : Int32 ) : weak< RoachRaceObstacle_Record >;
	public import function GetObstacleListItemHandle( index : Int32 ) : RoachRaceObstacle_Record;
	public import function ObstacleListContains( item : weak< RoachRaceObstacle_Record > ) : Bool;
	public import function PreLoadedResourceList() : array< ResRef >;
	public import function GetPreLoadedResourceListCount() : Int32;
	public import function GetPreLoadedResourceListItem( index : Int32 ) : ResRef;
	public import function Duration() : Float;
}

importonly class RoachRaceLevelList_Record extends TweakDBRecord
{
	public import function Data( out outList : array< weak< RoachRaceLevel_Record > > );
	public import function GetDataCount() : Int32;
	public import function GetDataItem( index : Int32 ) : weak< RoachRaceLevel_Record >;
	public import function GetDataItemHandle( index : Int32 ) : RoachRaceLevel_Record;
	public import function DataContains( item : weak< RoachRaceLevel_Record > ) : Bool;
}

importonly class RoachRaceMovement_Record extends TweakDBRecord
{
	public import function Range() : array< Float >;
	public import function GetRangeCount() : Int32;
	public import function GetRangeItem( index : Int32 ) : Float;
	public import function RangeContains( item : Float ) : Bool;
	public import function Name() : CName;
	public import function Value() : Float;
	public import function UsingRange() : Bool;
}

importonly class RoachRaceObject_Record extends ArcadeObject_Record
{
	public import function PositionRange() : array< Float >;
	public import function GetPositionRangeCount() : Int32;
	public import function GetPositionRangeItem( index : Int32 ) : Float;
	public import function PositionRangeContains( item : Float ) : Bool;
	public import function SpawnSFX() : CName;
	public import function BoundingRectangleRelativeArea() : Vector2;
	public import function Position() : Float;
	public import function Probability() : Float;
	public import function Score() : Float;
	public import function UsingPositionRange() : Bool;
}

importonly class RoachRaceObstacle_Record extends RoachRaceObject_Record
{
	public import function Movement() : weak< RoachRaceMovement_Record >;
	public import function MovementHandle() : RoachRaceMovement_Record;
	public import function VelocityMultiplierRange() : array< Vector2 >;
	public import function GetVelocityMultiplierRangeCount() : Int32;
	public import function GetVelocityMultiplierRangeItem( index : Int32 ) : Vector2;
	public import function VelocityMultiplierRangeContains( item : Vector2 ) : Bool;
	public import function Velocity() : Vector2;
	public import function UsingVelocityMultiplierRange() : Bool;
}

importonly class RoachRaceObstacleTexturePartPair_Record extends TweakDBRecord
{
	public import function Name() : CName;
	public import function ImageTexturePart() : CName;
}

importonly class RoachRacePowerUpList_Record extends TweakDBRecord
{
	public import function Data( out outList : array< weak< RoachRaceObject_Record > > );
	public import function GetDataCount() : Int32;
	public import function GetDataItem( index : Int32 ) : weak< RoachRaceObject_Record >;
	public import function GetDataItemHandle( index : Int32 ) : RoachRaceObject_Record;
	public import function DataContains( item : weak< RoachRaceObject_Record > ) : Bool;
}

importonly class RotationLimiter_Record extends DriveHelper_Record
{
	public import function DriftLimit() : Float;
	public import function DriftFullAngleBegin() : Float;
	public import function DriftLimitMaxVel() : Float;
	public import function HandbrakeLimit() : Float;
	public import function DriftExceededAngle() : Float;
	public import function DriftLimitStartVel() : Float;
	public import function MaxAngularSpeedRad() : Float;
	public import function DriftFullAngleEnd() : Float;
	public import function SmoothingTime() : Float;
}

importonly class RowSymbols_Record extends TweakDBRecord
{
	public import function Symbols() : array< Int32 >;
	public import function GetSymbolsCount() : Int32;
	public import function GetSymbolsItem( index : Int32 ) : Int32;
	public import function SymbolsContains( item : Int32 ) : Bool;
}

importonly class RowTraps_Record extends TweakDBRecord
{
	public import function Traps() : array< Int32 >;
	public import function GetTrapsCount() : Int32;
	public import function GetTrapsItem( index : Int32 ) : Int32;
	public import function TrapsContains( item : Int32 ) : Bool;
}

importonly class Rule_Record extends TweakDBRecord
{
	public import function Stimulus() : weak< StimType_Record >;
	public import function StimulusHandle() : StimType_Record;
	public import function Output() : weak< Output_Record >;
	public import function OutputHandle() : Output_Record;
	public import function WorkspotOutput() : CName;
	public import function Cooldown() : Float;
}

importonly class ScannableData_Record extends TweakDBRecord
{
	public import function FriendlyName() : String;
	public import function IconRecord() : weak< UIIcon_Record >;
	public import function IconRecordHandle() : UIIcon_Record;
	public import function LocalizedDescription() : CName;
	public import function LocalizedName() : CName;
	public import function IconName() : CName;
}

importonly class ScannerModuleVisibilityPreset_Record extends TweakDBRecord
{
	public import function ShoulShowName() : Bool;
	public import function ShouldShowLevel() : Bool;
	public import function ShouldShowBounty() : Bool;
	public import function ShouldShowFaction() : Bool;
	public import function ShouldShowWeaponData() : Bool;
	public import function ShouldShowSquadInfo() : Bool;
	public import function ShouldShowRarity() : Bool;
	public import function ShouldShowHealth() : Bool;
	public import function ShouldShowAttitude() : Bool;
	public import function ShouldShowVulnerabilities() : Bool;
	public import function ShouldShowResistances() : Bool;
	public import function ShouldShowQuestClues() : Bool;
	public import function ShouldShowNetworkStatus() : Bool;
}

importonly class SceneCameraDoF_Record extends TweakDBRecord
{
	public import function ProfileName() : CName;
	public import function DofNearFocus() : Float;
	public import function DofFarBlur() : Float;
	public import function DofNearBlur() : Float;
	public import function DofFarFocus() : Float;
	public import function DofIntensity() : Float;
	public import function UseNearPlane() : Bool;
	public import function UseFarPlane() : Bool;
}

importonly class SceneInterruptionScenarios_Record extends TweakDBRecord
{
	public import function ScenarioNames() : array< CName >;
	public import function GetScenarioNamesCount() : Int32;
	public import function GetScenarioNamesItem( index : Int32 ) : CName;
	public import function ScenarioNamesContains( item : CName ) : Bool;
}

importonly class SceneResources_Record extends TweakDBRecord
{
	public import function ResRefs() : array< ResRef >;
	public import function GetResRefsCount() : Int32;
	public import function GetResRefsItem( index : Int32 ) : ResRef;
}

importonly class ScreenMessageData_Record extends TweakDBRecord
{
	public import function FriendlyName() : String;
	public import function FontPath() : String;
	public import function BackgroundTextureID() : weak< UIIcon_Record >;
	public import function BackgroundTextureIDHandle() : UIIcon_Record;
	public import function MessageGroup() : weak< ScreenMessagesList_Record >;
	public import function MessageGroupHandle() : ScreenMessagesList_Record;
	public import function TextColor() : array< Int32 >;
	public import function GetTextColorCount() : Int32;
	public import function GetTextColorItem( index : Int32 ) : Int32;
	public import function TextColorContains( item : Int32 ) : Bool;
	public import function BackgroundColor() : array< Int32 >;
	public import function GetBackgroundColorCount() : Int32;
	public import function GetBackgroundColorItem( index : Int32 ) : Int32;
	public import function BackgroundColorContains( item : Int32 ) : Bool;
	public import function TextVerticalAlignment() : CName;
	public import function FontStyle() : CName;
	public import function LocalizedDescription() : CName;
	public import function TextHorizontalAlignment() : CName;
	public import function LocalizedName() : CName;
	public import function RightMargin() : Float;
	public import function LeftMargin() : Float;
	public import function BottomMargin() : Float;
	public import function FontSize() : Int32;
	public import function TopMargin() : Float;
	public import function BackgroundOpacity() : Float;
	public import function ScrollSpeed() : Float;
	public import function AutoScroll() : Bool;
}

importonly class ScreenMessagesList_Record extends TweakDBRecord
{
	public import function Messages( out outList : array< weak< ScreenMessageData_Record > > );
	public import function GetMessagesCount() : Int32;
	public import function GetMessagesItem( index : Int32 ) : weak< ScreenMessageData_Record >;
	public import function GetMessagesItemHandle( index : Int32 ) : ScreenMessageData_Record;
	public import function MessagesContains( item : weak< ScreenMessageData_Record > ) : Bool;
}

importonly class SearchFilterMaskType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataSearchFilterMaskType;
}

importonly class SearchFilterMaskTypeCond_Record extends SearchFilterMaskTypeCondition_Record
{
	public import function Values( out outList : array< weak< SearchFilterMaskType_Record > > );
	public import function GetValuesCount() : Int32;
	public import function GetValuesItem( index : Int32 ) : weak< SearchFilterMaskType_Record >;
	public import function GetValuesItemHandle( index : Int32 ) : SearchFilterMaskType_Record;
	public import function ValuesContains( item : weak< SearchFilterMaskType_Record > ) : Bool;
	public import function OpType() : CName;
}

importonly class SearchFilterMaskTypeCondition_Record extends TweakDBRecord
{
}

importonly class SearchFilterMaskTypeValue_Record extends SearchFilterMaskTypeCondition_Record
{
	public import function Values( out outList : array< weak< SearchFilterMaskType_Record > > );
	public import function GetValuesCount() : Int32;
	public import function GetValuesItem( index : Int32 ) : weak< SearchFilterMaskType_Record >;
	public import function GetValuesItemHandle( index : Int32 ) : SearchFilterMaskType_Record;
	public import function ValuesContains( item : weak< SearchFilterMaskType_Record > ) : Bool;
	public import function OpType() : CName;
}

importonly class SeatState_Record extends TweakDBRecord
{
	public import function ForceOpen() : Bool;
	public import function ForceClose() : Bool;
	public import function EnableInteraction() : Bool;
	public import function ForceUnlock() : Bool;
	public import function DisableInteraction() : Bool;
	public import function ForceLock() : Bool;
	public import function QuestLock() : Bool;
}

importonly class SectorSelector_Record extends TweakDBRecord
{
	public import function HomeRight() : Bool;
	public import function TargetMid() : Bool;
	public import function TargetLeft() : Bool;
	public import function TargetBackRight() : Bool;
	public import function TargetBackMid() : Bool;
	public import function HomeMid() : Bool;
	public import function TargetBackLeft() : Bool;
	public import function HomeLeft() : Bool;
	public import function TargetRight() : Bool;
	public import function HomeBackLeft() : Bool;
	public import function HomeBackMid() : Bool;
	public import function HomeBackRight() : Bool;
	public import function DefensiveSelection() : Bool;
}

importonly class SenseObjectType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataSenseObjectType;
}

importonly class SensePreset_Record extends TweakDBRecord
{
	public import function Shapes( out outList : array< weak< SenseShape_Record > > );
	public import function GetShapesCount() : Int32;
	public import function GetShapesItem( index : Int32 ) : weak< SenseShape_Record >;
	public import function GetShapesItemHandle( index : Int32 ) : SenseShape_Record;
	public import function ShapesContains( item : weak< SenseShape_Record > ) : Bool;
	public import function Curves( out outList : array< weak< DetectionCurve_Record > > );
	public import function GetCurvesCount() : Int32;
	public import function GetCurvesItem( index : Int32 ) : weak< DetectionCurve_Record >;
	public import function GetCurvesItemHandle( index : Int32 ) : DetectionCurve_Record;
	public import function CurvesContains( item : weak< DetectionCurve_Record > ) : Bool;
	public import function MaterialCurves( out outList : array< weak< DetectionCurve_Record > > );
	public import function GetMaterialCurvesCount() : Int32;
	public import function GetMaterialCurvesItem( index : Int32 ) : weak< DetectionCurve_Record >;
	public import function GetMaterialCurvesItemHandle( index : Int32 ) : DetectionCurve_Record;
	public import function MaterialCurvesContains( item : weak< DetectionCurve_Record > ) : Bool;
	public import function DayNightCurve() : CName;
	public import function DetectionDropFactor() : Float;
	public import function DetectionDifficultyModifierNormal() : Float;
	public import function DetectionCoolDownTime() : Float;
	public import function DetectionDifficultyModifierEasy() : Float;
	public import function DetectionDifficultyModifierHard() : Float;
	public import function DetectionPartCoolDownTime() : Float;
	public import function DetectionFactor() : Float;
	public import function DetectionDifficultyModifierVeryHard() : Float;
	public import function UseZCorrection() : Bool;
	public import function IgnorePhysicsTest() : Bool;
}

importonly class SenseShape_Record extends TweakDBRecord
{
	public import function Name() : CName;
	public import function DetectionMultiplier() : Float;
}

importonly class SetAttackHitTypeEffector_Record extends Effector_Record
{
	public import function HitType() : CName;
}

importonly class ShooterAI_Record extends ShooterObject_Record
{
	public import function LibraryWidget() : String;
	public import function SfxDamage() : CName;
	public import function SfxDead() : CName;
	public import function MoveSpeed() : Float;
	public import function Health() : Float;
	public import function CollisionDelay() : Float;
}

importonly class ShooterBackground_Record extends TweakDBRecord
{
	public import function LayerList( out outList : array< weak< ShooterLayerInfo_Record > > );
	public import function GetLayerListCount() : Int32;
	public import function GetLayerListItem( index : Int32 ) : weak< ShooterLayerInfo_Record >;
	public import function GetLayerListItemHandle( index : Int32 ) : ShooterLayerInfo_Record;
	public import function LayerListContains( item : weak< ShooterLayerInfo_Record > ) : Bool;
	public import function StartSFX() : CName;
	public import function StopSFX() : CName;
}

importonly class ShooterBasilisk_Record extends ShooterBossAI_Record
{
	public import function SfxDud() : CName;
	public import function SfxExplosion() : CName;
	public import function MissileOffset() : Float;
	public import function MissileHealthPercent() : Float;
	public import function TurretHealthPercent() : Float;
	public import function MissileEnhancedSpeed() : Float;
	public import function MissileCount() : Int32;
	public import function CannonHealthPercent() : Float;
	public import function CannonMoveDistance() : Float;
	public import function TurretBulletCount() : Int32;
	public import function EnragedTurretBulletCount() : Int32;
	public import function MissleFireRate() : Float;
	public import function EnragedTurretInterval() : Float;
	public import function RammingSpeedTime() : Float;
	public import function CannonCount() : Int32;
	public import function CannonCoolDown() : Float;
	public import function MissileCoolDown() : Float;
	public import function CannonFireRate() : Float;
	public import function EnragedCannonCount() : Int32;
	public import function MissileExplosionRange() : Float;
	public import function RammingSpeed() : Float;
	public import function EnragedMissileCount() : Int32;
	public import function TurretInterval() : Float;
}

importonly class ShooterBossAI_Record extends ShooterAI_Record
{
	public import function HealthThreshold() : Int32;
	public import function IdleDuration() : Float;
}

importonly class ShooterBullet_Record extends ShooterObject_Record
{
	public import function LibraryWidget() : String;
	public import function Speed() : Float;
	public import function Scale() : Float;
	public import function ExplosionRange() : Float;
	public import function SpecialValue() : Float;
	public import function Value() : Float;
	public import function Damage() : Float;
}

importonly class ShooterBulletList_Record extends TweakDBRecord
{
	public import function Data( out outList : array< weak< ShooterBullet_Record > > );
	public import function GetDataCount() : Int32;
	public import function GetDataItem( index : Int32 ) : weak< ShooterBullet_Record >;
	public import function GetDataItemHandle( index : Int32 ) : ShooterBullet_Record;
	public import function DataContains( item : weak< ShooterBullet_Record > ) : Bool;
}

importonly class ShooterFlyingDrone_Record extends ShooterProjectileAI_Record
{
	public import function FireRate() : Float;
	public import function Bobbing() : Float;
	public import function DetectionRange() : Float;
}

importonly class ShooterGameplay_Record extends ArcadeGameplay_Record
{
	public import function BasiliskTDBID() : CName;
	public import function MeleeTDBID() : CName;
	public import function PowerupDroneTDBID() : CName;
	public import function RangeTDBID() : CName;
	public import function FlyingDroneTDBID() : CName;
	public import function NinjaTDBID() : CName;
	public import function VipTDBID() : CName;
	public import function TransporterTDBID() : CName;
	public import function BarrelTDBID() : CName;
	public import function SpiderDroneTDBID() : CName;
	public import function VipPlatTDBID() : CName;
	public import function LandMineTDBID() : CName;
	public import function ShieldDroneTDBID() : CName;
	public import function MeatheadTDBID() : CName;
	public import function PlayerTDBID() : CName;
	public import function RangeGrenadeTDBID() : CName;
	public import function AttackDroneTDBID() : CName;
	public import function RescueTransporterTDBID() : CName;
	public import function PickUpTransporterTDBID() : CName;
	public import function ArcadeShooterStartMusic() : CName;
	public import function ArcadeShooterStopMusic() : CName;
	public import function ArcadeShooterGameplayMusic() : CName;
	public import function ArcadeShooterMenuMusic() : CName;
}

importonly class ShooterLayerInfo_Record extends TweakDBRecord
{
	public import function ImageTextureAtlas() : ResRef;
	public import function ImageTexturePart() : CName;
	public import function ImageName() : CName;
}

importonly class ShooterLevel_Record extends TweakDBRecord
{
	public import function LevelWidget() : String;
	public import function PlatformLibrary() : String;
	public import function VariantType() : String;
	public import function Background() : weak< ShooterBackground_Record >;
	public import function BackgroundHandle() : ShooterBackground_Record;
	public import function PreLoadedResourceList() : array< ResRef >;
	public import function GetPreLoadedResourceListCount() : Int32;
	public import function GetPreLoadedResourceListItem( index : Int32 ) : ResRef;
	public import function LevelNumber() : Int32;
}

importonly class ShooterLevelList_Record extends TweakDBRecord
{
	public import function Data( out outList : array< weak< ShooterLevel_Record > > );
	public import function GetDataCount() : Int32;
	public import function GetDataItem( index : Int32 ) : weak< ShooterLevel_Record >;
	public import function GetDataItemHandle( index : Int32 ) : ShooterLevel_Record;
	public import function DataContains( item : weak< ShooterLevel_Record > ) : Bool;
}

importonly class ShooterMeathead_Record extends ShooterBossAI_Record
{
	public import function BarrelThrowRate() : Float;
	public import function BarrelCount() : Int32;
	public import function LeapCount() : Int32;
	public import function LeapCoolDown() : Float;
	public import function LeapInterval() : Float;
	public import function BarrelCoolDown() : Float;
	public import function BarrelExplosionRange() : Float;
	public import function DebrisCoolDown() : Float;
	public import function EnragedBarrelCount() : Int32;
	public import function EnragedDebrisCount() : Int32;
	public import function EnragedLeapCount() : Int32;
	public import function DebrisSpawnRate() : Float;
	public import function DebrisCount() : Int32;
	public import function DebrisOffset() : Float;
	public import function LeapSpeed() : Float;
}

importonly class ShooterMelee_Record extends ShooterAI_Record
{
	public import function WraithVariant() : ResRef;
	public import function AnimalVariant2() : ResRef;
	public import function AnimalVariant() : ResRef;
	public import function TigerVariant() : ResRef;
	public import function TigerVariant2() : ResRef;
	public import function WraithVariant2() : ResRef;
	public import function DetectionRange() : Float;
}

importonly class ShooterNPCDrone_Record extends ShooterAI_Record
{
	public import function FireRate() : Float;
	public import function Bobbing() : Float;
	public import function Duration() : Float;
}

importonly class ShooterNinja_Record extends ShooterBossAI_Record
{
	public import function WaveCount() : Int32;
	public import function DashChargeRate() : Float;
	public import function EnragedWaveCount() : Int32;
	public import function FireRate() : Float;
	public import function DashCount() : Int32;
	public import function ChargeCoolDown() : Float;
	public import function EnragedDashCount() : Int32;
	public import function WaveCoolDown() : Float;
}

importonly class ShooterObject_Record extends ArcadeObject_Record
{
	public import function Max_gravity() : Float;
	public import function Score() : Float;
	public import function Gravity() : Float;
}

importonly class ShooterPickUpTransporter_Record extends ShooterAI_Record
{
	public import function PickUpTime() : Float;
}

importonly class ShooterPlayerData_Record extends TweakDBRecord
{
	public import function SgTextureAtlas() : ResRef;
	public import function LmgTextureAtlas() : ResRef;
	public import function ArTextureAtlas() : ResRef;
	public import function LsTextureAtlas() : ResRef;
	public import function MlTextureAtlas() : ResRef;
	public import function DefaultWeapon() : CName;
	public import function SfxDamage() : CName;
	public import function SfxDead() : CName;
	public import function SfxJump() : CName;
	public import function ProneSize() : Vector2;
	public import function JumpSize() : Vector2;
	public import function Gravity() : Float;
	public import function MaxHealth() : Int32;
	public import function EndMoveLerpTime() : Float;
	public import function StartMoveLerpTime() : Float;
	public import function MovementSpeed() : Float;
	public import function SquadDistanceCap() : Float;
	public import function ColliderAnchorPointOffset() : Float;
	public import function CutSceneDelay() : Float;
	public import function MinOpacity() : Float;
	public import function FadeTime() : Float;
	public import function JumpSpeed() : Float;
	public import function BaseMemberFollowDelay() : Float;
	public import function InvincibleTime() : Float;
	public import function AnalogThreshold() : Float;
}

importonly class ShooterPowerUpList_Record extends TweakDBRecord
{
	public import function Data( out outList : array< weak< ShooterPowerup_Record > > );
	public import function GetDataCount() : Int32;
	public import function GetDataItem( index : Int32 ) : weak< ShooterPowerup_Record >;
	public import function GetDataItemHandle( index : Int32 ) : ShooterPowerup_Record;
	public import function DataContains( item : weak< ShooterPowerup_Record > ) : Bool;
}

importonly class ShooterPowerup_Record extends ShooterObject_Record
{
	public import function LibraryWidget() : String;
	public import function SfxPick() : CName;
	public import function Value() : Float;
	public import function Scale() : Float;
}

importonly class ShooterProjectileAI_Record extends ShooterAI_Record
{
	public import function FireDelay() : Float;
}

importonly class ShooterProp_Record extends ShooterAI_Record
{
	public import function ExplosionRange() : Float;
	public import function ExplosionDamage() : Float;
}

importonly class ShooterRange_Record extends ShooterProjectileAI_Record
{
	public import function WraithVariant() : ResRef;
	public import function AnimalVariant2() : ResRef;
	public import function AnimalVariant() : ResRef;
	public import function TigerVariant() : ResRef;
	public import function TigerVariant2() : ResRef;
	public import function WraithVariant2() : ResRef;
	public import function HeliDetectionRange() : Float;
	public import function DetectionRange() : Float;
	public import function FireRate() : Float;
}

importonly class ShooterRangeGrenade_Record extends ShooterProjectileAI_Record
{
	public import function WraithVariant() : ResRef;
	public import function AnimalVariant2() : ResRef;
	public import function AnimalVariant() : ResRef;
	public import function TigerVariant() : ResRef;
	public import function TigerVariant2() : ResRef;
	public import function WraithVariant2() : ResRef;
	public import function HeliDetectionRange() : Float;
	public import function DetectionRange() : Float;
	public import function FireRate() : Float;
}

importonly class ShooterRescueTransporter_Record extends ShooterAI_Record
{
}

importonly class ShooterSpiderDrone_Record extends ShooterAI_Record
{
	public import function AttackDistance() : Float;
	public import function AttackSpeed() : Float;
}

importonly class ShooterTransporter_Record extends ShooterAI_Record
{
	public import function DropSpeed() : Float;
}

importonly class ShooterVFX_Record extends ShooterObject_Record
{
	public import function LibraryWidget() : String;
	public import function AllowCollision() : Bool;
	public import function AllowLoop() : Bool;
	public import function AllowSelfReset() : Bool;
}

importonly class ShooterVFXList_Record extends TweakDBRecord
{
	public import function Data( out outList : array< weak< ShooterVFX_Record > > );
	public import function GetDataCount() : Int32;
	public import function GetDataItem( index : Int32 ) : weak< ShooterVFX_Record >;
	public import function GetDataItemHandle( index : Int32 ) : ShooterVFX_Record;
	public import function DataContains( item : weak< ShooterVFX_Record > ) : Bool;
}

importonly class ShooterVIP_Record extends ShooterAI_Record
{
	public import function SpawnDuration() : Float;
}

importonly class ShooterWeaponData_Record extends TweakDBRecord
{
	public import function UpgradedBulletTextureAtlas() : ResRef;
	public import function ImageTexturePart() : CName;
	public import function ImageTextureAtlas() : ResRef;
	public import function UpgradedBulletTexturePart() : CName;
	public import function Name() : CName;
	public import function SfxShoot() : CName;
	public import function Value() : Float;
	public import function Rounds() : Int32;
	public import function Interval() : Float;
	public import function Cooldown() : Float;
	public import function UpgradedValue() : Float;
	public import function SpecialValue() : Float;
}

importonly class ShooterWeaponList_Record extends TweakDBRecord
{
	public import function Data( out outList : array< weak< ShooterWeaponData_Record > > );
	public import function GetDataCount() : Int32;
	public import function GetDataItem( index : Int32 ) : weak< ShooterWeaponData_Record >;
	public import function GetDataItemHandle( index : Int32 ) : ShooterWeaponData_Record;
	public import function DataContains( item : weak< ShooterWeaponData_Record > ) : Bool;
}

importonly class SlotItemPartElement_Record extends TweakDBRecord
{
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
	public import function Weight() : Float;
}

importonly class SlotItemPartListElement_Record extends TweakDBRecord
{
	public import function OptionalProbabilityCurveName() : String;
	public import function Slot() : weak< AttachmentSlot_Record >;
	public import function SlotHandle() : AttachmentSlot_Record;
	public import function ItemPartList( out outList : array< weak< ItemPartListElement_Record > > );
	public import function GetItemPartListCount() : Int32;
	public import function GetItemPartListItem( index : Int32 ) : weak< ItemPartListElement_Record >;
	public import function GetItemPartListItemHandle( index : Int32 ) : ItemPartListElement_Record;
	public import function ItemPartListContains( item : weak< ItemPartListElement_Record > ) : Bool;
}

importonly class SlotItemPartPreset_Record extends TweakDBRecord
{
	public import function Slot() : weak< AttachmentSlot_Record >;
	public import function SlotHandle() : AttachmentSlot_Record;
	public import function ItemPartPreset() : weak< Item_Record >;
	public import function ItemPartPresetHandle() : Item_Record;
	public import function ItemPartList( out outList : array< weak< ItemPartListElement_Record > > );
	public import function GetItemPartListCount() : Int32;
	public import function GetItemPartListItem( index : Int32 ) : weak< ItemPartListElement_Record >;
	public import function GetItemPartListItemHandle( index : Int32 ) : ItemPartListElement_Record;
	public import function ItemPartListContains( item : weak< ItemPartListElement_Record > ) : Bool;
}

importonly class SmartGunHandlerParams_Record extends TweakDBRecord
{
	public import function Blacklist( out outList : array< weak< AimAssistTargetData_Record > > );
	public import function GetBlacklistCount() : Int32;
	public import function GetBlacklistItem( index : Int32 ) : weak< AimAssistTargetData_Record >;
	public import function GetBlacklistItemHandle( index : Int32 ) : AimAssistTargetData_Record;
	public import function BlacklistContains( item : weak< AimAssistTargetData_Record > ) : Bool;
}

importonly class SmartGunMissParams_Record extends TweakDBRecord
{
	public import function SpiralCycleTimeMax() : Float;
	public import function MinMissAngleYaw() : Float;
	public import function SpiralRampDownFactor() : Float;
	public import function SpiralRampUpDistanceEnd() : Float;
	public import function SpiralRadius() : Float;
	public import function MinMissAnglePitch() : Float;
	public import function SpiralRampUpDistanceStart() : Float;
	public import function MaxMissAnglePitch() : Float;
	public import function SpiralRampDownDistanceEnd() : Float;
	public import function SpiralRampDownDistanceStart() : Float;
	public import function SpiralCycleTimeMin() : Float;
	public import function AreaToIgnoreHalfYaw() : Float;
	public import function MaxMissAngleYaw() : Float;
	public import function Gravity() : Float;
	public import function SpiralRandomizePhase() : Bool;
}

importonly class SmartGunTargetSortConfigurations_Record extends TweakDBRecord
{
	public import function HipConfig() : weak< SmartGunTargetSortData_Record >;
	public import function HipConfigHandle() : SmartGunTargetSortData_Record;
	public import function AdsConfig() : weak< SmartGunTargetSortData_Record >;
	public import function AdsConfigHandle() : SmartGunTargetSortData_Record;
}

importonly class SmartGunTargetSortData_Record extends TweakDBRecord
{
	public import function AngleDistUnitSq() : Float;
	public import function WorldProximityThresholdSq() : Float;
	public import function AngleDistUnitWeightSq() : Float;
	public import function WorldProximityBonusSq() : Float;
	public import function AngleProximityThresholdSq() : Float;
	public import function AngleProximityBonusSq() : Float;
	public import function WorldDistUnitSq() : Float;
	public import function WorldDistUnitWeightSq() : Float;
	public import function PreviouslyLockedBonusSq() : Float;
}

importonly class SpawnableObject_Record extends BaseObject_Record
{
	public import function Priority() : weak< SpawnableObjectPriority_Record >;
	public import function PriorityHandle() : SpawnableObjectPriority_Record;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function VisualTags() : array< CName >;
	public import function GetVisualTagsCount() : Int32;
	public import function GetVisualTagsItem( index : Int32 ) : CName;
	public import function VisualTagsContains( item : CName ) : Bool;
	public import function MultiplayerTemplatePaths() : array< ResRef >;
	public import function GetMultiplayerTemplatePathsCount() : Int32;
	public import function GetMultiplayerTemplatePathsItem( index : Int32 ) : ResRef;
	public import function AppearanceName() : CName;
	public import function PersistentName() : CName;
	public import function EntityTemplatePath() : ResRef;
}

importonly class SpawnableObjectPriority_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataSpawnableObjectPriority;
}

importonly class SpreadAreaEffector_Record extends Effector_Record
{
	public import function ObjectActions( out outList : array< weak< ObjectAction_Record > > );
	public import function GetObjectActionsCount() : Int32;
	public import function GetObjectActionsItem( index : Int32 ) : weak< ObjectAction_Record >;
	public import function GetObjectActionsItemHandle( index : Int32 ) : ObjectAction_Record;
	public import function ObjectActionsContains( item : weak< ObjectAction_Record > ) : Bool;
	public import function MaxTargetNum() : Int32;
	public import function Range() : Float;
}

importonly class SpreadEffector_Record extends Effector_Record
{
	public import function ObjectAction() : weak< ObjectAction_Record >;
	public import function ObjectActionHandle() : ObjectAction_Record;
	public import function EffectTag() : CName;
	public import function SpreadToAllTargetsInTheArea() : Bool;
}

importonly class SpreadInitEffector_Record extends Effector_Record
{
	public import function ObjectAction() : weak< ObjectAction_Record >;
	public import function ObjectActionHandle() : ObjectAction_Record;
	public import function SpreadCount() : Int32;
	public import function BonusJumps() : Int32;
	public import function SpreadDistance() : Int32;
	public import function ApplyOverclock() : Bool;
}

importonly class SquadBackyardBase_Record extends TweakDBRecord
{
	public import function PaddingFrom() : Float;
	public import function PaddingTo() : Float;
}

importonly class SquadBase_Record extends TweakDBRecord
{
	public import function DefensiveLeftFence() : weak< SquadFenceBase_Record >;
	public import function DefensiveLeftFenceHandle() : SquadFenceBase_Record;
	public import function DefensiveBackyard() : weak< SquadBackyardBase_Record >;
	public import function DefensiveBackyardHandle() : SquadBackyardBase_Record;
	public import function OffensiveBackyard() : weak< SquadBackyardBase_Record >;
	public import function OffensiveBackyardHandle() : SquadBackyardBase_Record;
	public import function DefensiveRightFence() : weak< SquadFenceBase_Record >;
	public import function DefensiveRightFenceHandle() : SquadFenceBase_Record;
	public import function OffensiveRightFence() : weak< SquadFenceBase_Record >;
	public import function OffensiveRightFenceHandle() : SquadFenceBase_Record;
	public import function OffensiveLeftFence() : weak< SquadFenceBase_Record >;
	public import function OffensiveLeftFenceHandle() : SquadFenceBase_Record;
	public import function ScriptHandler() : CName;
	public import function SquadParams() : CName;
	public import function HasActiveAlley() : Bool;
}

importonly class SquadFenceBase_Record extends TweakDBRecord
{
	public import function PaddingInnerFence() : Float;
	public import function PaddingOuterFence() : Float;
}

importonly class SquadInstance_Record extends TweakDBRecord
{
	public import function SquadName() : CName;
	public import function SquadTemplate() : CName;
}

importonly class Stat_Record extends TweakDBRecord
{
	public import function LocalizedDescription() : String;
	public import function LocalizedStatDisplay() : String;
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function LocalizedName() : String;
	public import function ImprovementRelation() : weak< ImprovementRelation_Record >;
	public import function ImprovementRelationHandle() : ImprovementRelation_Record;
	public import function Flags() : array< CName >;
	public import function GetFlagsCount() : Int32;
	public import function GetFlagsItem( index : Int32 ) : CName;
	public import function FlagsContains( item : CName ) : Bool;
	public import function Substats( out outList : array< weak< Substat_Record > > );
	public import function GetSubstatsCount() : Int32;
	public import function GetSubstatsItem( index : Int32 ) : weak< Substat_Record >;
	public import function GetSubstatsItemHandle( index : Int32 ) : Substat_Record;
	public import function SubstatsContains( item : weak< Substat_Record > ) : Bool;
	public import function Themes() : array< CName >;
	public import function GetThemesCount() : Int32;
	public import function GetThemesItem( index : Int32 ) : CName;
	public import function ThemesContains( item : CName ) : Bool;
	public import function DecimalPlaces() : Int32;
	public import function Min() : Float;
	public import function Max() : Float;
	public import function InMeters() : Bool;
	public import function MultiplyBy100InText() : Bool;
	public import function InSpeed() : Bool;
	public import function DisplayPercent() : Bool;
	public import function InSeconds() : Bool;
	public import function CanBeForcedByQuests() : Bool;
	public import function DisplayPlus() : Bool;
	public import function RoundValue() : Bool;
	public import function StatType() : gamedataStatType;
}

importonly class StatChangedPrereq_Record extends IPrereq_Record
{
	public import function StatType() : CName;
	public import function ObjectToCheck() : CName;
	public import function ChangeType() : CName;
}

importonly class StatDistributionData_Record extends TweakDBRecord
{
	public import function StatType() : weak< Stat_Record >;
	public import function StatTypeHandle() : Stat_Record;
	public import function Value() : Float;
}

importonly class StatModifier_Record extends TweakDBRecord
{
	public import function StatType() : weak< Stat_Record >;
	public import function StatTypeHandle() : Stat_Record;
	public import function ModifierType() : CName;
}

importonly class StatModifierGroup_Record extends TweakDBRecord
{
	public import function StatModsLimitModifier() : weak< StatModifier_Record >;
	public import function StatModsLimitModifierHandle() : StatModifier_Record;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function RelatedModifierGroups( out outList : array< weak< StatModifierGroup_Record > > );
	public import function GetRelatedModifierGroupsCount() : Int32;
	public import function GetRelatedModifierGroupsItem( index : Int32 ) : weak< StatModifierGroup_Record >;
	public import function GetRelatedModifierGroupsItemHandle( index : Int32 ) : StatModifierGroup_Record;
	public import function RelatedModifierGroupsContains( item : weak< StatModifierGroup_Record > ) : Bool;
	public import function StatModsLimit() : Int32;
	public import function SaveBasedOnStatType() : Bool;
	public import function DrawBasedOnStatType() : Bool;
	public import function OptimiseCombinedModifiers() : Bool;
}

importonly class StatPool_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function Stat() : weak< Stat_Record >;
	public import function StatHandle() : Stat_Record;
	public import function Regen() : weak< PoolValueModifier_Record >;
	public import function RegenHandle() : PoolValueModifier_Record;
	public import function Decay() : weak< PoolValueModifier_Record >;
	public import function DecayHandle() : PoolValueModifier_Record;
	public import function EnumName() : CName;
	public import function InitialValue() : Float;
	public import function EnableDefeated() : Bool;
	public import function Savable() : Bool;
	public import function StatPoolType() : gamedataStatPoolType;
}

importonly class StatPoolCost_Record extends ObjectActionCost_Record
{
	public import function StatPool() : weak< StatPool_Record >;
	public import function StatPoolHandle() : StatPool_Record;
}

importonly class StatPoolDistributionData_Record extends TweakDBRecord
{
	public import function StatPoolType() : weak< StatPool_Record >;
	public import function StatPoolTypeHandle() : StatPool_Record;
	public import function Value() : Float;
}

importonly class StatPoolPrereq_Record extends IPrereq_Record
{
	public import function ValueToCheck( out outList : array< weak< StatModifier_Record > > );
	public import function GetValueToCheckCount() : Int32;
	public import function GetValueToCheckItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetValueToCheckItemHandle( index : Int32 ) : StatModifier_Record;
	public import function ValueToCheckContains( item : weak< StatModifier_Record > ) : Bool;
	public import function ComparisonType() : CName;
	public import function StatPoolType() : CName;
	public import function ObjectToCheck() : CName;
	public import function SkipOnApply() : Bool;
	public import function ListenConstantly() : Bool;
	public import function ComparePercentage() : Bool;
}

importonly class StatPoolUpdate_Record extends TweakDBRecord
{
	public import function StatPoolType() : weak< StatPool_Record >;
	public import function StatPoolTypeHandle() : StatPool_Record;
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function StatPoolValue() : Float;
}

importonly class StatPrereq_Record extends IPrereq_Record
{
	public import function StatModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetStatModifiersCount() : Int32;
	public import function GetStatModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetStatModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function StatModifiersContains( item : weak< StatModifier_Record > ) : Bool;
	public import function ComparisonType() : CName;
	public import function StatType() : CName;
	public import function ObjectToCheck() : CName;
	public import function ValueToCheck() : Float;
	public import function NotifyOnAnyChange() : Bool;
	public import function NotifyOnlyOnStateFulfilled() : Bool;
}

importonly class StatsArray_Record extends TweakDBRecord
{
	public import function EnumStats( out outList : array< weak< Stat_Record > > );
	public import function GetEnumStatsCount() : Int32;
	public import function GetEnumStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetEnumStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function EnumStatsContains( item : weak< Stat_Record > ) : Bool;
	public import function AdditionalStats( out outList : array< weak< Stat_Record > > );
	public import function GetAdditionalStatsCount() : Int32;
	public import function GetAdditionalStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetAdditionalStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function AdditionalStatsContains( item : weak< Stat_Record > ) : Bool;
	public import function ArrayName() : CName;
}

importonly class StatsFolder_Record extends TweakDBRecord
{
	public import function Stats( out outList : array< weak< Stat_Record > > );
	public import function GetStatsCount() : Int32;
	public import function GetStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function StatsContains( item : weak< Stat_Record > ) : Bool;
	public import function Folders( out outList : array< weak< StatsFolder_Record > > );
	public import function GetFoldersCount() : Int32;
	public import function GetFoldersItem( index : Int32 ) : weak< StatsFolder_Record >;
	public import function GetFoldersItemHandle( index : Int32 ) : StatsFolder_Record;
	public import function FoldersContains( item : weak< StatsFolder_Record > ) : Bool;
	public import function Arrays( out outList : array< weak< StatsArray_Record > > );
	public import function GetArraysCount() : Int32;
	public import function GetArraysItem( index : Int32 ) : weak< StatsArray_Record >;
	public import function GetArraysItemHandle( index : Int32 ) : StatsArray_Record;
	public import function ArraysContains( item : weak< StatsArray_Record > ) : Bool;
}

importonly class StatsList_Record extends TweakDBRecord
{
	public import function Stats( out outList : array< weak< Stat_Record > > );
	public import function GetStatsCount() : Int32;
	public import function GetStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function StatsContains( item : weak< Stat_Record > ) : Bool;
}

importonly class StatusEffect_Record extends TweakDBRecord
{
	public import function MaxStacks() : weak< StatModifierGroup_Record >;
	public import function MaxStacksHandle() : StatModifierGroup_Record;
	public import function RemoveAllStacksWhenDurationEndsStatModifiers() : weak< StatModifierGroup_Record >;
	public import function RemoveAllStacksWhenDurationEndsStatModifiersHandle() : StatModifierGroup_Record;
	public import function StatusEffectType() : weak< StatusEffectType_Record >;
	public import function StatusEffectTypeHandle() : StatusEffectType_Record;
	public import function Duration() : weak< StatModifierGroup_Record >;
	public import function DurationHandle() : StatModifierGroup_Record;
	public import function UiData() : weak< StatusEffectUIData_Record >;
	public import function UiDataHandle() : StatusEffectUIData_Record;
	public import function AIData() : weak< StatusEffectAIData_Record >;
	public import function AIDataHandle() : StatusEffectAIData_Record;
	public import function PlayerData() : weak< StatusEffectPlayerData_Record >;
	public import function PlayerDataHandle() : StatusEffectPlayerData_Record;
	public import function DebugTags() : array< CName >;
	public import function GetDebugTagsCount() : Int32;
	public import function GetDebugTagsItem( index : Int32 ) : CName;
	public import function DebugTagsContains( item : CName ) : Bool;
	public import function GameplayTags() : array< CName >;
	public import function GetGameplayTagsCount() : Int32;
	public import function GetGameplayTagsItem( index : Int32 ) : CName;
	public import function GameplayTagsContains( item : CName ) : Bool;
	public import function SFX( out outList : array< weak< StatusEffectFX_Record > > );
	public import function GetSFXCount() : Int32;
	public import function GetSFXItem( index : Int32 ) : weak< StatusEffectFX_Record >;
	public import function GetSFXItemHandle( index : Int32 ) : StatusEffectFX_Record;
	public import function SFXContains( item : weak< StatusEffectFX_Record > ) : Bool;
	public import function VFX( out outList : array< weak< StatusEffectFX_Record > > );
	public import function GetVFXCount() : Int32;
	public import function GetVFXItem( index : Int32 ) : weak< StatusEffectFX_Record >;
	public import function GetVFXItemHandle( index : Int32 ) : StatusEffectFX_Record;
	public import function VFXContains( item : weak< StatusEffectFX_Record > ) : Bool;
	public import function ImmunityStats( out outList : array< weak< Stat_Record > > );
	public import function GetImmunityStatsCount() : Int32;
	public import function GetImmunityStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetImmunityStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function ImmunityStatsContains( item : weak< Stat_Record > ) : Bool;
	public import function Packages( out outList : array< weak< GameplayLogicPackage_Record > > );
	public import function GetPackagesCount() : Int32;
	public import function GetPackagesItem( index : Int32 ) : weak< GameplayLogicPackage_Record >;
	public import function GetPackagesItemHandle( index : Int32 ) : GameplayLogicPackage_Record;
	public import function PackagesContains( item : weak< GameplayLogicPackage_Record > ) : Bool;
	public import function AdditionalParam() : CName;
	public import function StopActiveSfxOnDeactivate() : Bool;
	public import function IsAffectedByTimeDilationPlayer() : Bool;
	public import function RemoveOnStoryTier() : Bool;
	public import function ReapplyPackagesOnMaxStacks() : Bool;
	public import function Savable() : Bool;
	public import function RemoveAllStacksWhenDurationEnds() : Bool;
	public import function IsAffectedByTimeDilationNPC() : Bool;
	public import function Replicated() : Bool;
	public import function DynamicDuration() : Bool;
}

importonly class StatusEffectAIBehaviorFlag_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataStatusEffectAIBehaviorFlag;
}

importonly class StatusEffectAIBehaviorType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataStatusEffectAIBehaviorType;
}

importonly class StatusEffectAIData_Record extends TweakDBRecord
{
	public import function BehaviorEventFlag() : weak< StatusEffectAIBehaviorFlag_Record >;
	public import function BehaviorEventFlagHandle() : StatusEffectAIBehaviorFlag_Record;
	public import function BehaviorType() : weak< StatusEffectAIBehaviorType_Record >;
	public import function BehaviorTypeHandle() : StatusEffectAIBehaviorType_Record;
	public import function SensePreset() : weak< SensePreset_Record >;
	public import function SensePresetHandle() : SensePreset_Record;
	public import function Stimulis( out outList : array< weak< Stim_Record > > );
	public import function GetStimulisCount() : Int32;
	public import function GetStimulisItem( index : Int32 ) : weak< Stim_Record >;
	public import function GetStimulisItemHandle( index : Int32 ) : Stim_Record;
	public import function StimulisContains( item : weak< Stim_Record > ) : Bool;
	public import function ActivationPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetActivationPrereqsCount() : Int32;
	public import function GetActivationPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetActivationPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function ActivationPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function BehaviorSignalResendDelay( out outList : array< weak< StatModifier_Record > > );
	public import function GetBehaviorSignalResendDelayCount() : Int32;
	public import function GetBehaviorSignalResendDelayItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetBehaviorSignalResendDelayItemHandle( index : Int32 ) : StatModifier_Record;
	public import function BehaviorSignalResendDelayContains( item : weak< StatModifier_Record > ) : Bool;
	public import function BehaviourName() : CName;
	public import function Priority() : Float;
	public import function StimRangeMultiplier() : Float;
	public import function UpdateSenses() : Bool;
	public import function ShouldDelayStatusEffectApplication() : Bool;
	public import function ShouldProcessAIDataOnReapplication() : Bool;
	public import function AllowDelayStatusEffectSignalIfSamePriorityExecuting() : Bool;
}

importonly class StatusEffectAttackData_Record extends TweakDBRecord
{
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function ResistPool() : weak< StatPool_Record >;
	public import function ResistPoolHandle() : StatPool_Record;
	public import function StacksToApply() : Float;
	public import function ApplyImmediately() : Bool;
}

importonly class StatusEffectFX_Record extends TweakDBRecord
{
	public import function Name() : CName;
	public import function ShouldReapply() : Bool;
}

importonly class StatusEffectPlayerData_Record extends TweakDBRecord
{
	public import function StatusEffectVariation() : weak< StatusEffectVariation_Record >;
	public import function StatusEffectVariationHandle() : StatusEffectVariation_Record;
	public import function AirRecoveryAnimDuration() : Float;
	public import function ImpulseDistance() : Float;
	public import function Priority() : Float;
	public import function RecoveryAnimDuration() : Float;
	public import function StartupAnimDuration() : Float;
	public import function CameraShakeStrength() : Float;
	public import function StartupAnimInterruptPoint() : Float;
	public import function LandAnimDuration() : Float;
	public import function RotateToSource() : Bool;
	public import function DisableJump() : Bool;
	public import function BlockMovement() : Bool;
	public import function ForceUnequipWeapon() : Bool;
	public import function DisableCrouch() : Bool;
	public import function ForceSafeWeapon() : Bool;
	public import function DisableSprint() : Bool;
	public import function JamWeapon() : Bool;
	public import function CameraInputInterference() : Bool;
	public import function DisableDodge() : Bool;
	public import function ScaleImpulseDistance() : Bool;
}

importonly class StatusEffectPrereq_Record extends IPrereq_Record
{
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function CheckType() : weak< CheckType_Record >;
	public import function CheckTypeHandle() : CheckType_Record;
	public import function TagToCheck() : CName;
	public import function ObjectToCheck() : CName;
	public import function EvaluateOnRegister() : Bool;
	public import function Invert() : Bool;
}

importonly class StatusEffectType_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataStatusEffectType;
}

importonly class StatusEffectUIData_Record extends TweakDBRecord
{
	public import function DisplayName() : String;
	public import function Description() : String;
	public import function FluffText() : String;
	public import function IconPath() : String;
	public import function FloatValues() : array< Float >;
	public import function GetFloatValuesCount() : Int32;
	public import function GetFloatValuesItem( index : Int32 ) : Float;
	public import function FloatValuesContains( item : Float ) : Bool;
	public import function IntValues() : array< Int32 >;
	public import function GetIntValuesCount() : Int32;
	public import function GetIntValuesItem( index : Int32 ) : Int32;
	public import function IntValuesContains( item : Int32 ) : Bool;
	public import function NameValues() : array< CName >;
	public import function GetNameValuesCount() : Int32;
	public import function GetNameValuesItem( index : Int32 ) : CName;
	public import function NameValuesContains( item : CName ) : Bool;
	public import function Stats( out outList : array< weak< Stat_Record > > );
	public import function GetStatsCount() : Int32;
	public import function GetStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function StatsContains( item : weak< Stat_Record > ) : Bool;
	public import function Priority() : Float;
}

importonly class StatusEffectVariation_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataStatusEffectVariation;
}

importonly class StatusEffect_inline0_Record extends StatModifierGroup_Record
{
}

importonly class StatusEffect_inline1_Record extends ConstantStatModifier_Record
{
}

importonly class StickyGDM_Record extends GrenadeDeliveryMethod_Record
{
}

importonly class Stim_Record extends TweakDBRecord
{
	public import function Propagation() : weak< StimPropagation_Record >;
	public import function PropagationHandle() : StimPropagation_Record;
	public import function Type() : weak< StimType_Record >;
	public import function TypeHandle() : StimType_Record;
	public import function Priority() : weak< StimPriority_Record >;
	public import function PriorityHandle() : StimPriority_Record;
	public import function Targets() : weak< StimTargets_Record >;
	public import function TargetsHandle() : StimTargets_Record;
	public import function Tags() : array< CName >;
	public import function GetTagsCount() : Int32;
	public import function GetTagsItem( index : Int32 ) : CName;
	public import function TagsContains( item : CName ) : Bool;
	public import function Category() : CName;
	public import function Interval() : Float;
	public import function Radius() : Float;
	public import function Fear() : Float;
	public import function Aggressive() : Float;
	public import function IsReactionStim() : Bool;
}

importonly class StimPriority_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataStimPriority;
}

importonly class StimPropagation_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataStimPropagation;
}

importonly class StimTargets_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataStimTargets;
}

importonly class StimType_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataStimType;
}

importonly class Stop_Record extends ProjectileCollision_Record
{
}

importonly class StopAndStick_Record extends ProjectileCollision_Record
{
}

importonly class StopAndStickPerpendicular_Record extends ProjectileCollision_Record
{
}

importonly class StrategyData_Record extends TweakDBRecord
{
	public import function VehicleSpawnAngleRange() : Vector2;
	public import function VehicleSpawnDistanceRangeHighway() : Vector2;
	public import function VehicleSpawnDistanceRange() : Vector2;
	public import function MinDistanceBetweenSpawningVehicles() : Vector2;
	public import function VehicleSpawnDistanceRangeOnFoot() : Vector2;
	public import function PlayerToIntersectionDistance() : Vector2;
	public import function MinDirectDistance() : Float;
}

importonly class StreetCredTier_Record extends TweakDBRecord
{
	public import function StreetCredRequirement() : Int32;
}

importonly class StreetSign_Record extends BaseSign_Record
{
}

importonly class SubCharacter_Record extends Character_Record
{
	public import function EnumComment() : String;
	public import function StartingEquippedItems( out outList : array< weak< Item_Record > > );
	public import function GetStartingEquippedItemsCount() : Int32;
	public import function GetStartingEquippedItemsItem( index : Int32 ) : weak< Item_Record >;
	public import function GetStartingEquippedItemsItemHandle( index : Int32 ) : Item_Record;
	public import function StartingEquippedItemsContains( item : weak< Item_Record > ) : Bool;
	public import function ReferenceName() : CName;
	public import function EnumName() : CName;
	public import function IsPrevention() : Bool;
	public import function Type() : gamedataSubCharacter;
}

importonly class SubStatModifier_Record extends StatModifier_Record
{
	public import function RefStat() : weak< Stat_Record >;
	public import function RefStatHandle() : Stat_Record;
	public import function RefObject() : CName;
}

importonly class Substat_Record extends Stat_Record
{
	public import function ModifierType() : CName;
}

importonly class TPPCameraSetup_Record extends TweakDBRecord
{
	public import function CurvesPath() : ResRef;
	public import function Pivot() : Vector3;
	public import function Pivot_z_offset_lerp_speed() : Float;
	public import function Boom_length_lerp_speed() : Float;
	public import function Shake_max_pitch() : Float;
	public import function Manual_control_reset_timeout() : Float;
	public import function Pivot_x_offset_lerp_speed() : Float;
	public import function Shake_max_roll() : Float;
	public import function Gear_changing_boom_modifier() : Float;
	public import function Boom_length_acc_mod_multiplier() : Float;
	public import function Gear_changing_fov_modifier() : Float;
	public import function Fov_lerp_speed() : Float;
	public import function Boom_length_base() : Float;
	public import function Boom_length_min_value() : Float;
	public import function Gear_changing_pitch_modifier() : Float;
	public import function Shake_frequency() : Float;
	public import function Camera_collision_sweep_small_sphere_radius() : Float;
	public import function Auto_center_speed_threshold() : Float;
	public import function Boom_length_acc_mod_reaction_speed() : Float;
	public import function Shake_max_yaw() : Float;
	public import function Reverse_camera_speed_threshold() : Float;
	public import function Camera_collision_sweep_big_sphere_radius() : Float;
	public import function Boom_pitch_lerp_speed() : Float;
	public import function Boom_length_no_accumulated_acc_impulses() : Int32;
	public import function Camera_centric_vertical_offset() : Float;
	public import function Boom_yaw_lerp_speed() : Float;
	public import function Boom_length_dec_mod_reaction_speed() : Float;
	public import function Debug_boom_length() : Float;
	public import function Debug_boom_roll() : Float;
	public import function Debug_boom_pitch() : Float;
	public import function Debug_boom_yaw() : Float;
	public import function Debug_fov() : Float;
	public import function Camera_transition_min_boom_length() : Float;
	public import function Camera_transition_time_activation() : Float;
	public import function Camera_transition_time_deactivation() : Float;
	public import function Camera_transition_time_deactivation_quick() : Float;
	public import function Enable_camera_auto_center() : Bool;
	public import function Debug_static_camera() : Bool;
}

importonly class TPPLookAtPresets_Record extends TweakDBRecord
{
	public import function NoWeaponPresets( out outList : array< weak< LookAtPreset_Record > > );
	public import function GetNoWeaponPresetsCount() : Int32;
	public import function GetNoWeaponPresetsItem( index : Int32 ) : weak< LookAtPreset_Record >;
	public import function GetNoWeaponPresetsItemHandle( index : Int32 ) : LookAtPreset_Record;
	public import function NoWeaponPresetsContains( item : weak< LookAtPreset_Record > ) : Bool;
	public import function WeaponReadyPresets( out outList : array< weak< LookAtPreset_Record > > );
	public import function GetWeaponReadyPresetsCount() : Int32;
	public import function GetWeaponReadyPresetsItem( index : Int32 ) : weak< LookAtPreset_Record >;
	public import function GetWeaponReadyPresetsItemHandle( index : Int32 ) : LookAtPreset_Record;
	public import function WeaponReadyPresetsContains( item : weak< LookAtPreset_Record > ) : Bool;
	public import function ReloadPresets( out outList : array< weak< LookAtPreset_Record > > );
	public import function GetReloadPresetsCount() : Int32;
	public import function GetReloadPresetsItem( index : Int32 ) : weak< LookAtPreset_Record >;
	public import function GetReloadPresetsItemHandle( index : Int32 ) : LookAtPreset_Record;
	public import function ReloadPresetsContains( item : weak< LookAtPreset_Record > ) : Bool;
	public import function WeaponSafePresets( out outList : array< weak< LookAtPreset_Record > > );
	public import function GetWeaponSafePresetsCount() : Int32;
	public import function GetWeaponSafePresetsItem( index : Int32 ) : weak< LookAtPreset_Record >;
	public import function GetWeaponSafePresetsItemHandle( index : Int32 ) : LookAtPreset_Record;
	public import function WeaponSafePresetsContains( item : weak< LookAtPreset_Record > ) : Bool;
}

importonly class TVBase_Record extends Device_Record
{
	public import function Channels( out outList : array< weak< ChannelData_Record > > );
	public import function GetChannelsCount() : Int32;
	public import function GetChannelsItem( index : Int32 ) : weak< ChannelData_Record >;
	public import function GetChannelsItemHandle( index : Int32 ) : ChannelData_Record;
	public import function ChannelsContains( item : weak< ChannelData_Record > ) : Bool;
}

importonly class TacticLimiterCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function AddUtilityValue() : Float;
}

importonly class TankArrangement_Record extends TweakDBRecord
{
	public import function Arrangement() : array< Int32 >;
	public import function GetArrangementCount() : Int32;
	public import function GetArrangementItem( index : Int32 ) : Int32;
	public import function ArrangementContains( item : Int32 ) : Bool;
	public import function SpawnableObjectIDList( out outList : array< weak< ArcadeSpawnableID_Record > > );
	public import function GetSpawnableObjectIDListCount() : Int32;
	public import function GetSpawnableObjectIDListItem( index : Int32 ) : weak< ArcadeSpawnableID_Record >;
	public import function GetSpawnableObjectIDListItemHandle( index : Int32 ) : ArcadeSpawnableID_Record;
	public import function SpawnableObjectIDListContains( item : weak< ArcadeSpawnableID_Record > ) : Bool;
	public import function SpawnableReplacementObjectIDList( out outList : array< weak< ArcadeSpawnableID_Record > > );
	public import function GetSpawnableReplacementObjectIDListCount() : Int32;
	public import function GetSpawnableReplacementObjectIDListItem( index : Int32 ) : weak< ArcadeSpawnableID_Record >;
	public import function GetSpawnableReplacementObjectIDListItemHandle( index : Int32 ) : ArcadeSpawnableID_Record;
	public import function SpawnableReplacementObjectIDListContains( item : weak< ArcadeSpawnableID_Record > ) : Bool;
	public import function SpawnableReplacementObjectCount() : array< Int32 >;
	public import function GetSpawnableReplacementObjectCountCount() : Int32;
	public import function GetSpawnableReplacementObjectCountItem( index : Int32 ) : Int32;
	public import function SpawnableReplacementObjectCountContains( item : Int32 ) : Bool;
}

importonly class TankBackgroundData_Record extends TweakDBRecord
{
	public import function BackgroundLayerList( out outList : array< weak< ArcadeBackgroundLayer_Record > > );
	public import function GetBackgroundLayerListCount() : Int32;
	public import function GetBackgroundLayerListItem( index : Int32 ) : weak< ArcadeBackgroundLayer_Record >;
	public import function GetBackgroundLayerListItemHandle( index : Int32 ) : ArcadeBackgroundLayer_Record;
	public import function BackgroundLayerListContains( item : weak< ArcadeBackgroundLayer_Record > ) : Bool;
	public import function DecorationSpawnerTDBID() : CName;
}

importonly class TankDecorationSpawnerData_Record extends TweakDBRecord
{
	public import function LevelList( out outList : array< weak< TankLevelObject_Record > > );
	public import function GetLevelListCount() : Int32;
	public import function GetLevelListItem( index : Int32 ) : weak< TankLevelObject_Record >;
	public import function GetLevelListItemHandle( index : Int32 ) : TankLevelObject_Record;
	public import function LevelListContains( item : weak< TankLevelObject_Record > ) : Bool;
	public import function SpawnTime() : Float;
}

importonly class TankDestroyableObject_Record extends ArcadeCollidableObject_Record
{
	public import function ScoreMultiplier() : Float;
	public import function RammingInvincibilityTime() : Float;
	public import function Score() : Float;
	public import function DropProbability() : Float;
	public import function Health() : Int32;
}

importonly class TankDriveModelData_Record extends VehicleDriveModelData_Record
{
	public import function TankSpringsLocalPositions() : array< Vector2 >;
	public import function GetTankSpringsLocalPositionsCount() : Int32;
	public import function GetTankSpringsLocalPositionsItem( index : Int32 ) : Vector2;
	public import function TankSpringsLocalPositionsContains( item : Vector2 ) : Bool;
	public import function TankMaxSpeed() : Float;
	public import function TankAcceleration() : Float;
	public import function TankCTOI() : Float;
	public import function TankCTOP() : Float;
	public import function TankSpringVerticalOffset() : Float;
	public import function TankDeceleration() : Float;
	public import function TankTurningSpeed() : Float;
	public import function TankCTOD() : Float;
	public import function TankSpringRadius() : Float;
	public import function TankSpringDamping() : Float;
	public import function TankSpringDistance() : Float;
	public import function TankSpringStiffness() : Float;
	public import function TankGravityMul() : Float;
}

importonly class TankEnemy_Record extends TankDestroyableObject_Record
{
	public import function Weapon() : weak< TankWeapon_Record >;
	public import function WeaponHandle() : TankWeapon_Record;
	public import function HeadTexturePart() : CName;
	public import function HeadTextureAtlas() : ResRef;
	public import function HeadParentTranslation() : Vector2;
	public import function HeadAnchorPoint() : Vector2;
	public import function RammingDamage() : Int32;
	public import function Velocity() : Float;
	public import function IsTracker() : Bool;
}

importonly class TankEnemySpawnerData_Record extends TweakDBRecord
{
	public import function EnemyList( out outList : array< weak< TankEnemy_Record > > );
	public import function GetEnemyListCount() : Int32;
	public import function GetEnemyListItem( index : Int32 ) : weak< TankEnemy_Record >;
	public import function GetEnemyListItemHandle( index : Int32 ) : TankEnemy_Record;
	public import function EnemyListContains( item : weak< TankEnemy_Record > ) : Bool;
	public import function LevelList( out outList : array< weak< TankLevelSpawnableArrangement_Record > > );
	public import function GetLevelListCount() : Int32;
	public import function GetLevelListItem( index : Int32 ) : weak< TankLevelSpawnableArrangement_Record >;
	public import function GetLevelListItemHandle( index : Int32 ) : TankLevelSpawnableArrangement_Record;
	public import function LevelListContains( item : weak< TankLevelSpawnableArrangement_Record > ) : Bool;
	public import function ProjectileSpawnerTDBID() : CName;
	public import function SpawnTime() : Float;
}

importonly class TankGameplay_Record extends ArcadeGameplay_Record
{
	public import function GameplayData() : weak< TankGameplayData_Record >;
	public import function GameplayDataHandle() : TankGameplayData_Record;
	public import function BackgroundTDBID() : CName;
	public import function PlayerTDBID() : CName;
	public import function EnemySpawnerTDBID() : CName;
	public import function PickupSpawnerTDBID() : CName;
	public import function ObstacleSpawnerTDBID() : CName;
}

importonly class TankGameplayData_Record extends TweakDBRecord
{
	public import function ScoreMultiplierBreakpointList( out outList : array< weak< TankScoreMultiplierBreakpoint_Record > > );
	public import function GetScoreMultiplierBreakpointListCount() : Int32;
	public import function GetScoreMultiplierBreakpointListItem( index : Int32 ) : weak< TankScoreMultiplierBreakpoint_Record >;
	public import function GetScoreMultiplierBreakpointListItemHandle( index : Int32 ) : TankScoreMultiplierBreakpoint_Record;
	public import function ScoreMultiplierBreakpointListContains( item : weak< TankScoreMultiplierBreakpoint_Record > ) : Bool;
	public import function LevelList( out outList : array< weak< TankLevelGameplay_Record > > );
	public import function GetLevelListCount() : Int32;
	public import function GetLevelListItem( index : Int32 ) : weak< TankLevelGameplay_Record >;
	public import function GetLevelListItemHandle( index : Int32 ) : TankLevelGameplay_Record;
	public import function LevelListContains( item : weak< TankLevelGameplay_Record > ) : Bool;
	public import function WorldVelocity() : Vector2;
	public import function ScoreMultiplierDecayBlockedTime() : Float;
	public import function ScoreMultiplierDecayRate() : Float;
}

importonly class TankLevelGameplay_Record extends TweakDBRecord
{
	public import function PreLoadedResourceList() : array< ResRef >;
	public import function GetPreLoadedResourceListCount() : Int32;
	public import function GetPreLoadedResourceListItem( index : Int32 ) : ResRef;
	public import function StartSFX() : CName;
	public import function Duration() : Float;
}

importonly class TankLevelObject_Record extends TweakDBRecord
{
	public import function ObjectList( out outList : array< weak< ArcadeSpawnableObject_Record > > );
	public import function GetObjectListCount() : Int32;
	public import function GetObjectListItem( index : Int32 ) : weak< ArcadeSpawnableObject_Record >;
	public import function GetObjectListItemHandle( index : Int32 ) : ArcadeSpawnableObject_Record;
	public import function ObjectListContains( item : weak< ArcadeSpawnableObject_Record > ) : Bool;
}

importonly class TankLevelObjectID_Record extends TweakDBRecord
{
	public import function ObjectList( out outList : array< weak< ArcadeSpawnableID_Record > > );
	public import function GetObjectListCount() : Int32;
	public import function GetObjectListItem( index : Int32 ) : weak< ArcadeSpawnableID_Record >;
	public import function GetObjectListItemHandle( index : Int32 ) : ArcadeSpawnableID_Record;
	public import function ObjectListContains( item : weak< ArcadeSpawnableID_Record > ) : Bool;
}

importonly class TankLevelSpawnableArrangement_Record extends TweakDBRecord
{
	public import function ArrangementList( out outList : array< weak< TankSpawnableArrangement_Record > > );
	public import function GetArrangementListCount() : Int32;
	public import function GetArrangementListItem( index : Int32 ) : weak< TankSpawnableArrangement_Record >;
	public import function GetArrangementListItemHandle( index : Int32 ) : TankSpawnableArrangement_Record;
	public import function ArrangementListContains( item : weak< TankSpawnableArrangement_Record > ) : Bool;
}

importonly class TankObstacleSpawnerData_Record extends TweakDBRecord
{
	public import function ObstacleList( out outList : array< weak< TankDestroyableObject_Record > > );
	public import function GetObstacleListCount() : Int32;
	public import function GetObstacleListItem( index : Int32 ) : weak< TankDestroyableObject_Record >;
	public import function GetObstacleListItemHandle( index : Int32 ) : TankDestroyableObject_Record;
	public import function ObstacleListContains( item : weak< TankDestroyableObject_Record > ) : Bool;
	public import function LevelList( out outList : array< weak< TankLevelObjectID_Record > > );
	public import function GetLevelListCount() : Int32;
	public import function GetLevelListItem( index : Int32 ) : weak< TankLevelObjectID_Record >;
	public import function GetLevelListItemHandle( index : Int32 ) : TankLevelObjectID_Record;
	public import function LevelListContains( item : weak< TankLevelObjectID_Record > ) : Bool;
	public import function SpawnTime() : Float;
}

importonly class TankPickup_Record extends ArcadeCollidableObject_Record
{
	public import function PickupLocKey() : CName;
	public import function Value() : Int32;
}

importonly class TankPickupSpawnerData_Record extends TweakDBRecord
{
	public import function PickupList( out outList : array< weak< TankPickup_Record > > );
	public import function GetPickupListCount() : Int32;
	public import function GetPickupListItem( index : Int32 ) : weak< TankPickup_Record >;
	public import function GetPickupListItemHandle( index : Int32 ) : TankPickup_Record;
	public import function PickupListContains( item : weak< TankPickup_Record > ) : Bool;
}

importonly class TankPlayerData_Record extends TweakDBRecord
{
	public import function WeaponLevelList( out outList : array< weak< TankPlayerWeaponLevel_Record > > );
	public import function GetWeaponLevelListCount() : Int32;
	public import function GetWeaponLevelListItem( index : Int32 ) : weak< TankPlayerWeaponLevel_Record >;
	public import function GetWeaponLevelListItemHandle( index : Int32 ) : TankPlayerWeaponLevel_Record;
	public import function WeaponLevelListContains( item : weak< TankPlayerWeaponLevel_Record > ) : Bool;
	public import function ProjectileSpawnerTDBID() : CName;
	public import function Velocity() : Vector2;
	public import function MaxAEAMS() : Int32;
	public import function MaxHealth() : Int32;
	public import function RammingDamage() : Int32;
	public import function MaxLives() : Int32;
	public import function InvincibilityTime() : Float;
	public import function FlatlinedScorePenalty() : Float;
}

importonly class TankPlayerWeaponLevel_Record extends TweakDBRecord
{
	public import function WeaponList( out outList : array< weak< TankWeapon_Record > > );
	public import function GetWeaponListCount() : Int32;
	public import function GetWeaponListItem( index : Int32 ) : weak< TankWeapon_Record >;
	public import function GetWeaponListItemHandle( index : Int32 ) : TankWeapon_Record;
	public import function WeaponListContains( item : weak< TankWeapon_Record > ) : Bool;
}

importonly class TankProjectile_Record extends ArcadeCollidableObject_Record
{
	public import function Damage() : Int32;
	public import function Velocity() : Float;
}

importonly class TankProjectileSpawnerData_Record extends TweakDBRecord
{
	public import function ProjectileList( out outList : array< weak< TankProjectile_Record > > );
	public import function GetProjectileListCount() : Int32;
	public import function GetProjectileListItem( index : Int32 ) : weak< TankProjectile_Record >;
	public import function GetProjectileListItemHandle( index : Int32 ) : TankProjectile_Record;
	public import function ProjectileListContains( item : weak< TankProjectile_Record > ) : Bool;
}

importonly class TankScoreMultiplierBreakpoint_Record extends TweakDBRecord
{
	public import function Percentage() : Float;
	public import function Value() : Float;
}

importonly class TankSpawnableArrangement_Record extends TweakDBRecord
{
	public import function ObjectArrangementList( out outList : array< weak< TankArrangement_Record > > );
	public import function GetObjectArrangementListCount() : Int32;
	public import function GetObjectArrangementListItem( index : Int32 ) : weak< TankArrangement_Record >;
	public import function GetObjectArrangementListItemHandle( index : Int32 ) : TankArrangement_Record;
	public import function ObjectArrangementListContains( item : weak< TankArrangement_Record > ) : Bool;
	public import function Displacement() : CName;
	public import function Slot() : Vector2;
	public import function ColumnCount() : Int32;
	public import function Probability() : Float;
}

importonly class TankWeapon_Record extends ArcadeObject_Record
{
	public import function Rotation() : array< Vector2 >;
	public import function GetRotationCount() : Int32;
	public import function GetRotationItem( index : Int32 ) : Vector2;
	public import function RotationContains( item : Vector2 ) : Bool;
	public import function ProjectileID() : CName;
	public import function PerBurstProjectileCount() : Int32;
	public import function PerBurstProjectileSpawnInterval() : Float;
	public import function Rof() : Float;
	public import function ChargingTime() : Float;
}

importonly class TemporalPrereq_Record extends IPrereq_Record
{
	public import function Duration() : Float;
}

importonly class TerminalScreenType_Record extends DeviceScreenType_Record
{
}

importonly class ThreatDistanceCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function DistanceToThreatMultiplier() : Float;
	public import function ThreatPreferredDistance() : Float;
	public import function ThreatMinDistance() : Float;
	public import function ThreatMaxDistance() : Float;
	public import function ThreatPredictionTime() : Float;
	public import function CheckThreatDestination() : Bool;
	public import function CheckThreatPath() : Bool;
	public import function UseThreatMaxDistanceFiltering() : Bool;
	public import function AllowNegativeThreatMaxDistanceScoring() : Bool;
}

importonly class ThreatTrackingPresetBase_Record extends TweakDBRecord
{
	public import function BeliefAccuracy() : weak< Accuracy_Record >;
	public import function BeliefAccuracyHandle() : Accuracy_Record;
	public import function BaseAccuracy() : weak< Accuracy_Record >;
	public import function BaseAccuracyHandle() : Accuracy_Record;
	public import function MountedHysteresisThreatDrop() : Vector2;
	public import function BaseDroppingThreatCooldown() : Float;
	public import function DroppingCooldownPerSecondWhileVisible() : Float;
	public import function VisibleBeliefSpeedMultiplier() : Float;
	public import function DroppingCooldownPerHit() : Float;
	public import function MaximumDroppingCooldownValue() : Float;
	public import function MoveBeliefOnlyIfVisible() : Bool;
}

importonly class ThumbnailWidgetDefinition_Record extends WidgetDefinition_Record
{
}

importonly class Time_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
}

importonly class Tracking_Record extends ProjectileLaunch_Record
{
	public import function BendFactor() : Float;
	public import function HalfLeanAngle() : Float;
	public import function LinearTimeRatio() : Float;
	public import function ReturnTimeMargin() : Float;
	public import function BendTimeRatio() : Float;
	public import function InterpolationTimeRatio() : Float;
	public import function EndLeanAngle() : Float;
	public import function AngleInterpolationDuration() : Float;
}

importonly class TrackingMode_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataTrackingMode;
}

importonly class Trait_Record extends TweakDBRecord
{
	public import function Loc_desc_key() : String;
	public import function EnumComment() : String;
	public import function Loc_name_key() : String;
	public import function TraitIcon() : weak< UIIcon_Record >;
	public import function TraitIconHandle() : UIIcon_Record;
	public import function Requirement() : weak< IPrereq_Record >;
	public import function RequirementHandle() : IPrereq_Record;
	public import function BaseTraitData() : weak< TraitData_Record >;
	public import function BaseTraitDataHandle() : TraitData_Record;
	public import function InfiniteTraitData() : weak< TraitData_Record >;
	public import function InfiniteTraitDataHandle() : TraitData_Record;
	public import function EnumName() : CName;
	public import function Type() : gamedataTraitType;
}

importonly class TraitData_Record extends TweakDBRecord
{
	public import function Loc_name_key() : String;
	public import function Loc_desc_key() : String;
	public import function StatusEffect() : weak< StatusEffect_Record >;
	public import function StatusEffectHandle() : StatusEffect_Record;
	public import function DataPackage() : weak< GameplayLogicPackage_Record >;
	public import function DataPackageHandle() : GameplayLogicPackage_Record;
}

importonly class Transgression_Record extends TweakDBRecord
{
	public import function LocalizedDescription() : String;
	public import function DrawWeight() : Float;
	public import function Severity() : Float;
}

importonly class Trap_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Type() : weak< TrapType_Record >;
	public import function TypeHandle() : TrapType_Record;
	public import function Probability() : Float;
}

importonly class TrapType_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
}

importonly class TriggerAttackEffector_Record extends Effector_Record
{
	public import function AttackRecord() : weak< Attack_Record >;
	public import function AttackRecordHandle() : Attack_Record;
}

importonly class TriggerHackingMinigameEffector_Record extends Effector_Record
{
	public import function JournalEntry() : String;
	public import function Reward() : weak< RewardBase_Record >;
	public import function RewardHandle() : RewardBase_Record;
}

importonly class TriggerMode_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Type() : gamedataTriggerMode;
}

importonly class UIAnimation_Record extends TweakDBRecord
{
	public import function Profile() : weak< MappinUIRuntimeProfile_Record >;
	public import function ProfileHandle() : MappinUIRuntimeProfile_Record;
	public import function WidgetResource() : ResRef;
	public import function AnimationName() : CName;
	public import function Loop() : Bool;
}

importonly class UICharacterCreationAttribute_Record extends TweakDBRecord
{
	public import function Description() : String;
	public import function Shortcut() : String;
	public import function Attribute() : weak< Stat_Record >;
	public import function AttributeHandle() : Stat_Record;
	public import function IconPath() : CName;
	public import function Value() : Float;
}

importonly class UICharacterCreationAttributesPreset_Record extends TweakDBRecord
{
	public import function Attributes( out outList : array< weak< UICharacterCreationAttribute_Record > > );
	public import function GetAttributesCount() : Int32;
	public import function GetAttributesItem( index : Int32 ) : weak< UICharacterCreationAttribute_Record >;
	public import function GetAttributesItemHandle( index : Int32 ) : UICharacterCreationAttribute_Record;
	public import function AttributesContains( item : weak< UICharacterCreationAttribute_Record > ) : Bool;
}

importonly class UICharacterCustomizationResourcePaths_Record extends TweakDBRecord
{
	public import function MalePath() : ResRef;
	public import function FemalePath() : ResRef;
}

importonly class UICondition_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function IsCustom() : Bool;
	public import function Type() : gamedataUICondition;
}

importonly class UIElement_Record extends TweakDBRecord
{
	public import function CustomConditions( out outList : array< weak< UICondition_Record > > );
	public import function GetCustomConditionsCount() : Int32;
	public import function GetCustomConditionsItem( index : Int32 ) : weak< UICondition_Record >;
	public import function GetCustomConditionsItemHandle( index : Int32 ) : UICondition_Record;
	public import function CustomConditionsContains( item : weak< UICondition_Record > ) : Bool;
}

importonly class UIIcon_Record extends TweakDBRecord
{
	public import function AtlasResourcePath() : ResRef;
	public import function AtlasPartName() : CName;
}

importonly class UIIconCensorFlag_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataUIIconCensorFlag;
}

importonly class UIIconCensorship_Record extends TweakDBRecord
{
	public import function CensoredIcon() : weak< UIIcon_Record >;
	public import function CensoredIconHandle() : UIIcon_Record;
	public import function Replacer() : weak< UIIcon_Record >;
	public import function ReplacerHandle() : UIIcon_Record;
	public import function CensorFlags( out outList : array< weak< UIIconCensorFlag_Record > > );
	public import function GetCensorFlagsCount() : Int32;
	public import function GetCensorFlagsItem( index : Int32 ) : weak< UIIconCensorFlag_Record >;
	public import function GetCensorFlagsItemHandle( index : Int32 ) : UIIconCensorFlag_Record;
	public import function CensorFlagsContains( item : weak< UIIconCensorFlag_Record > ) : Bool;
}

importonly class UIIconPool_Record extends TweakDBRecord
{
	public import function Icons( out outList : array< weak< UIIcon_Record > > );
	public import function GetIconsCount() : Int32;
	public import function GetIconsItem( index : Int32 ) : weak< UIIcon_Record >;
	public import function GetIconsItemHandle( index : Int32 ) : UIIcon_Record;
	public import function IconsContains( item : weak< UIIcon_Record > ) : Bool;
}

importonly class UINameplate_Record extends TweakDBRecord
{
	public import function Type() : weak< UINameplateDisplayType_Record >;
	public import function TypeHandle() : UINameplateDisplayType_Record;
	public import function Slot() : CName;
	public import function Position() : Vector3;
	public import function Enabled() : Bool;
}

importonly class UINameplateDisplayType_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataUINameplateDisplayType;
}

importonly class UIStatsMap_Record extends TweakDBRecord
{
	public import function StatsToCompare( out outList : array< weak< Stat_Record > > );
	public import function GetStatsToCompareCount() : Int32;
	public import function GetStatsToCompareItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetStatsToCompareItemHandle( index : Int32 ) : Stat_Record;
	public import function StatsToCompareContains( item : weak< Stat_Record > ) : Bool;
	public import function SecondaryStats( out outList : array< weak< Stat_Record > > );
	public import function GetSecondaryStatsCount() : Int32;
	public import function GetSecondaryStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetSecondaryStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function SecondaryStatsContains( item : weak< Stat_Record > ) : Bool;
	public import function PrimaryStats( out outList : array< weak< Stat_Record > > );
	public import function GetPrimaryStatsCount() : Int32;
	public import function GetPrimaryStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetPrimaryStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function PrimaryStatsContains( item : weak< Stat_Record > ) : Bool;
	public import function TypesToCompareWith( out outList : array< weak< ItemType_Record > > );
	public import function GetTypesToCompareWithCount() : Int32;
	public import function GetTypesToCompareWithItem( index : Int32 ) : weak< ItemType_Record >;
	public import function GetTypesToCompareWithItemHandle( index : Int32 ) : ItemType_Record;
	public import function TypesToCompareWithContains( item : weak< ItemType_Record > ) : Bool;
	public import function TooltipStats( out outList : array< weak< Stat_Record > > );
	public import function GetTooltipStatsCount() : Int32;
	public import function GetTooltipStatsItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetTooltipStatsItemHandle( index : Int32 ) : Stat_Record;
	public import function TooltipStatsContains( item : weak< Stat_Record > ) : Bool;
}

importonly class UncontrolledMovementEffector_Record extends Effector_Record
{
	public import function DebugSourceName() : CName;
	public import function RagdollNoGroundThreshold() : Float;
	public import function RagdollOnCollision() : Bool;
}

importonly class UpgradingData_Record extends TweakDBRecord
{
	public import function Ingredients( out outList : array< weak< RecipeElement_Record > > );
	public import function GetIngredientsCount() : Int32;
	public import function GetIngredientsItem( index : Int32 ) : weak< RecipeElement_Record >;
	public import function GetIngredientsItemHandle( index : Int32 ) : RecipeElement_Record;
	public import function IngredientsContains( item : weak< RecipeElement_Record > ) : Bool;
}

importonly class UphillDriveHelper_Record extends DriveHelper_Record
{
	public import function SlopeCompensationFactor() : Float;
	public import function SlopeCompensationMaxAngle() : Float;
}

importonly class UseConsumableEffector_Record extends Effector_Record
{
}

importonly class UtilityLossCoverSelectionParameters_Record extends CoverSelectionParameters_Record
{
	public import function UtilityLossTimeoutCover() : Float;
	public import function UtilityLossMultiplier() : Float;
	public import function HitsTakenToClearScoreCover() : Int32;
	public import function HitsTakenToClearScoreInIdle() : Int32;
	public import function UtilityLossTimeoutShootingSpot() : Float;
	public import function UtilityLossTimeoutInIdle() : Float;
	public import function HitsTakenToClearScoreShootingSpot() : Int32;
}

importonly class ValueAssignment_Record extends ContentAssignment_Record
{
	public import function OverrideValue() : Int32;
}

importonly class Vehicle_Record extends SpawnableObject_Record
{
	public import function Player_audio_resource() : String;
	public import function Traffic_audio_resource() : String;
	public import function DebugStatusString() : String;
	public import function Model() : weak< VehicleModel_Record >;
	public import function ModelHandle() : VehicleModel_Record;
	public import function VehDefaultState() : weak< VehicleDefaultState_Record >;
	public import function VehDefaultStateHandle() : VehicleDefaultState_Record;
	public import function VehAirControlAI() : weak< VehicleAirControl_Record >;
	public import function VehAirControlAIHandle() : VehicleAirControl_Record;
	public import function TppCameraParams() : weak< VehicleTPPCameraParams_Record >;
	public import function TppCameraParamsHandle() : VehicleTPPCameraParams_Record;
	public import function VehPassL_FPPCameraParams() : weak< VehicleFPPCameraParams_Record >;
	public import function VehPassL_FPPCameraParamsHandle() : VehicleFPPCameraParams_Record;
	public import function VehPassCombatL_ProceduralFPPCameraParams() : weak< VehicleProceduralFPPCameraParams_Record >;
	public import function VehPassCombatL_ProceduralFPPCameraParamsHandle() : VehicleProceduralFPPCameraParams_Record;
	public import function DrivingParamsGeneric() : weak< BaseDrivingParameters_Record >;
	public import function DrivingParamsGenericHandle() : BaseDrivingParameters_Record;
	public import function VehAirControl() : weak< VehicleAirControl_Record >;
	public import function VehAirControlHandle() : VehicleAirControl_Record;
	public import function TrafficSuspension() : weak< VehicleTrafficSuspension_Record >;
	public import function TrafficSuspensionHandle() : VehicleTrafficSuspension_Record;
	public import function VehPassCombatL_FPPCameraParams() : weak< VehicleFPPCameraParams_Record >;
	public import function VehPassCombatL_FPPCameraParamsHandle() : VehicleFPPCameraParams_Record;
	public import function VehDriveModelData() : weak< VehicleDriveModelData_Record >;
	public import function VehDriveModelDataHandle() : VehicleDriveModelData_Record;
	public import function VehDriverCombat_FPPCameraParams() : weak< VehicleFPPCameraParams_Record >;
	public import function VehDriverCombat_FPPCameraParamsHandle() : VehicleFPPCameraParams_Record;
	public import function DrivingParamsRace() : weak< BaseDrivingParameters_Record >;
	public import function DrivingParamsRaceHandle() : BaseDrivingParameters_Record;
	public import function VehPassL_ProceduralFPPCameraParams() : weak< VehicleProceduralFPPCameraParams_Record >;
	public import function VehPassL_ProceduralFPPCameraParamsHandle() : VehicleProceduralFPPCameraParams_Record;
	public import function VehDriver_ProceduralFPPCameraParams() : weak< VehicleProceduralFPPCameraParams_Record >;
	public import function VehDriver_ProceduralFPPCameraParamsHandle() : VehicleProceduralFPPCameraParams_Record;
	public import function VehPassR_FPPCameraParams() : weak< VehicleFPPCameraParams_Record >;
	public import function VehPassR_FPPCameraParamsHandle() : VehicleFPPCameraParams_Record;
	public import function VehDriverCombat_ProceduralFPPCameraParams() : weak< VehicleProceduralFPPCameraParams_Record >;
	public import function VehDriverCombat_ProceduralFPPCameraParamsHandle() : VehicleProceduralFPPCameraParams_Record;
	public import function VehEngineData() : weak< VehicleEngineData_Record >;
	public import function VehEngineDataHandle() : VehicleEngineData_Record;
	public import function VehImpactTraffic() : weak< VehicleImpactTraffic_Record >;
	public import function VehImpactTrafficHandle() : VehicleImpactTraffic_Record;
	public import function Destruction() : weak< VehicleDestruction_Record >;
	public import function DestructionHandle() : VehicleDestruction_Record;
	public import function CameraManagerParams() : weak< VehicleCameraManager_Record >;
	public import function CameraManagerParamsHandle() : VehicleCameraManager_Record;
	public import function VisualDestruction() : weak< VehicleVisualDestruction_Record >;
	public import function VisualDestructionHandle() : VehicleVisualDestruction_Record;
	public import function Driving() : weak< BaseDrivingParameters_Record >;
	public import function DrivingHandle() : BaseDrivingParameters_Record;
	public import function Manufacturer() : weak< VehicleManufacturer_Record >;
	public import function ManufacturerHandle() : VehicleManufacturer_Record;
	public import function Icon() : weak< UIIcon_Record >;
	public import function IconHandle() : UIIcon_Record;
	public import function VehPassCombatR_FPPCameraParams() : weak< VehicleFPPCameraParams_Record >;
	public import function VehPassCombatR_FPPCameraParamsHandle() : VehicleFPPCameraParams_Record;
	public import function WeaponSafeModeBounds() : weak< WeaponSafeModeBounds_Record >;
	public import function WeaponSafeModeBoundsHandle() : WeaponSafeModeBounds_Record;
	public import function Affiliation() : weak< Affiliation_Record >;
	public import function AffiliationHandle() : Affiliation_Record;
	public import function DrivingParamsPanic() : weak< BaseDrivingParameters_Record >;
	public import function DrivingParamsPanicHandle() : BaseDrivingParameters_Record;
	public import function VehDriver_FPPCameraParams() : weak< VehicleFPPCameraParams_Record >;
	public import function VehDriver_FPPCameraParamsHandle() : VehicleFPPCameraParams_Record;
	public import function VehDataPackage() : weak< VehicleDataPackage_Record >;
	public import function VehDataPackageHandle() : VehicleDataPackage_Record;
	public import function CrowdMemberSettings() : weak< CrowdSettingsPackageBase_Record >;
	public import function CrowdMemberSettingsHandle() : CrowdSettingsPackageBase_Record;
	public import function FxWheelsDecals() : weak< VehicleFxWheelsDecals_Record >;
	public import function FxWheelsDecalsHandle() : VehicleFxWheelsDecals_Record;
	public import function FxWheelsDecalsFrontOverride() : weak< VehicleFxWheelsDecals_Record >;
	public import function FxWheelsDecalsFrontOverrideHandle() : VehicleFxWheelsDecals_Record;
	public import function Type() : weak< VehicleType_Record >;
	public import function TypeHandle() : VehicleType_Record;
	public import function VehBehaviorData() : weak< VehicleBehaviorData_Record >;
	public import function VehBehaviorDataHandle() : VehicleBehaviorData_Record;
	public import function VehPassCombatR_ProceduralFPPCameraParams() : weak< VehicleProceduralFPPCameraParams_Record >;
	public import function VehPassCombatR_ProceduralFPPCameraParamsHandle() : VehicleProceduralFPPCameraParams_Record;
	public import function BikeDriveModelData() : weak< BikeDriveModelData_Record >;
	public import function BikeDriveModelDataHandle() : BikeDriveModelData_Record;
	public import function FxWheelsParticles() : weak< VehicleFxWheelsParticles_Record >;
	public import function FxWheelsParticlesHandle() : VehicleFxWheelsParticles_Record;
	public import function TankDriveModelData() : weak< TankDriveModelData_Record >;
	public import function TankDriveModelDataHandle() : TankDriveModelData_Record;
	public import function IsHackable() : weak< IsHackable_Record >;
	public import function IsHackableHandle() : IsHackable_Record;
	public import function VehPassR_ProceduralFPPCameraParams() : weak< VehicleProceduralFPPCameraParams_Record >;
	public import function VehPassR_ProceduralFPPCameraParamsHandle() : VehicleProceduralFPPCameraParams_Record;
	public import function FxCollision() : weak< VehicleFxCollision_Record >;
	public import function FxCollisionHandle() : VehicleFxCollision_Record;
	public import function VehDriveModelDataAI() : weak< VehicleDriveModelData_Record >;
	public import function VehDriveModelDataAIHandle() : VehicleDriveModelData_Record;
	public import function VehicleUIData() : weak< VehicleUIData_Record >;
	public import function VehicleUIDataHandle() : VehicleUIData_Record;
	public import function VehWheelDimensionsSetup() : weak< VehicleWheelDimensionsSetup_Record >;
	public import function VehWheelDimensionsSetupHandle() : VehicleWheelDimensionsSetup_Record;
	public import function RightBLinkerlightColor() : array< Int32 >;
	public import function GetRightBLinkerlightColorCount() : Int32;
	public import function GetRightBLinkerlightColorItem( index : Int32 ) : Int32;
	public import function RightBLinkerlightColorContains( item : Int32 ) : Bool;
	public import function QueryOnlyExceptions() : array< CName >;
	public import function GetQueryOnlyExceptionsCount() : Int32;
	public import function GetQueryOnlyExceptionsItem( index : Int32 ) : CName;
	public import function QueryOnlyExceptionsContains( item : CName ) : Bool;
	public import function RandomPassengers( out outList : array< weak< RandomPassengerEntry_Record > > );
	public import function GetRandomPassengersCount() : Int32;
	public import function GetRandomPassengersItem( index : Int32 ) : weak< RandomPassengerEntry_Record >;
	public import function GetRandomPassengersItemHandle( index : Int32 ) : RandomPassengerEntry_Record;
	public import function RandomPassengersContains( item : weak< RandomPassengerEntry_Record > ) : Bool;
	public import function PreventionPassengers( out outList : array< weak< Character_Record > > );
	public import function GetPreventionPassengersCount() : Int32;
	public import function GetPreventionPassengersItem( index : Int32 ) : weak< Character_Record >;
	public import function GetPreventionPassengersItemHandle( index : Int32 ) : Character_Record;
	public import function PreventionPassengersContains( item : weak< Character_Record > ) : Bool;
	public import function HeadlightColor() : array< Int32 >;
	public import function GetHeadlightColorCount() : Int32;
	public import function GetHeadlightColorItem( index : Int32 ) : Int32;
	public import function HeadlightColorContains( item : Int32 ) : Bool;
	public import function UtilityLightColor() : array< Int32 >;
	public import function GetUtilityLightColorCount() : Int32;
	public import function GetUtilityLightColorItem( index : Int32 ) : Int32;
	public import function UtilityLightColorContains( item : Int32 ) : Bool;
	public import function BrakelightColor() : array< Int32 >;
	public import function GetBrakelightColorCount() : Int32;
	public import function GetBrakelightColorItem( index : Int32 ) : Int32;
	public import function BrakelightColorContains( item : Int32 ) : Bool;
	public import function TppCameraPresets( out outList : array< weak< VehicleTPPCameraPresetParams_Record > > );
	public import function GetTppCameraPresetsCount() : Int32;
	public import function GetTppCameraPresetsItem( index : Int32 ) : weak< VehicleTPPCameraPresetParams_Record >;
	public import function GetTppCameraPresetsItemHandle( index : Int32 ) : VehicleTPPCameraPresetParams_Record;
	public import function TppCameraPresetsContains( item : weak< VehicleTPPCameraPresetParams_Record > ) : Bool;
	public import function ReverselightColor() : array< Int32 >;
	public import function GetReverselightColorCount() : Int32;
	public import function GetReverselightColorItem( index : Int32 ) : Int32;
	public import function ReverselightColorContains( item : Int32 ) : Bool;
	public import function InteriorDamageColor() : array< Int32 >;
	public import function GetInteriorDamageColorCount() : Int32;
	public import function GetInteriorDamageColorItem( index : Int32 ) : Int32;
	public import function InteriorDamageColorContains( item : Int32 ) : Bool;
	public import function Weapons( out outList : array< weak< VehicleWeapon_Record > > );
	public import function GetWeaponsCount() : Int32;
	public import function GetWeaponsItem( index : Int32 ) : weak< VehicleWeapon_Record >;
	public import function GetWeaponsItemHandle( index : Int32 ) : VehicleWeapon_Record;
	public import function WeaponsContains( item : weak< VehicleWeapon_Record > ) : Bool;
	public import function InteriorColor() : array< Int32 >;
	public import function GetInteriorColorCount() : Int32;
	public import function GetInteriorColorItem( index : Int32 ) : Int32;
	public import function InteriorColorContains( item : Int32 ) : Bool;
	public import function LeftBlinkerlightColor() : array< Int32 >;
	public import function GetLeftBlinkerlightColorCount() : Int32;
	public import function GetLeftBlinkerlightColorItem( index : Int32 ) : Int32;
	public import function LeftBlinkerlightColorContains( item : Int32 ) : Bool;
	public import function AttachmentSlots( out outList : array< weak< AttachmentSlot_Record > > );
	public import function GetAttachmentSlotsCount() : Int32;
	public import function GetAttachmentSlotsItem( index : Int32 ) : weak< AttachmentSlot_Record >;
	public import function GetAttachmentSlotsItemHandle( index : Int32 ) : AttachmentSlot_Record;
	public import function AttachmentSlotsContains( item : weak< AttachmentSlot_Record > ) : Bool;
	public import function DisplayName() : CName;
	public import function AudioResourceName() : CName;
	public import function CurvesPath() : ResRef;
	public import function WidgetStyleSheetPath() : ResRef;
	public import function ArchetypeName() : CName;
	public import function DestroyedAppearance() : CName;
	public import function CustomizableAppearance() : CName;
	public import function RightBackCamberOffset() : Vector3;
	public import function LeftFrontCamberOffset() : Vector3;
	public import function RightFrontCamberOffset() : Vector3;
	public import function LeftBackCamberOffset() : Vector3;
	public import function UnmountOffsetPosition() : Vector3;
	public import function RightBackCamber() : Float;
	public import function LeftFrontCamber() : Float;
	public import function LeftBackCamber() : Float;
	public import function HitCooldown() : Float;
	public import function RightFrontCamber() : Float;
	public import function MaxVehiclePassengersCount() : Int32;
	public import function MinVehiclePassengersCount() : Int32;
	public import function BlockadeLeftPassengerOffset() : Float;
	public import function BlockadeRightPassengerOffset() : Float;
	public import function HasSideWindows() : Bool;
	public import function UsesSecondaryHoodEmitter() : Bool;
	public import function EnableDestruction() : Bool;
	public import function HasVisualCustomization() : Bool;
	public import function IsArmoredVehicle() : Bool;
	public import function VisualCustomizationTeaser() : Bool;
}

importonly class VehicleAIBoostSettings_Record extends TweakDBRecord
{
	public import function MaxTorqueBoost() : Float;
	public import function MaxLongTractionBoost() : Float;
	public import function MaxLatTractionBoost() : Float;
}

importonly class VehicleAIPanicDrivingSettings_Record extends TweakDBRecord
{
	public import function BoostMaxSpeed() : Float;
	public import function CurvatureLookupRange() : Float;
	public import function BoostMinSpeed() : Float;
	public import function TopSpeed() : Float;
	public import function BasePanicSpeedIncrease() : Float;
	public import function PerLaneSpeedIncrease() : Float;
}

importonly class VehicleAITractionEstimation_Record extends TweakDBRecord
{
	public import function TurningAccelFactor() : Float;
	public import function ForwardAccelFactor() : Float;
	public import function BrakingAccelFactor() : Float;
}

importonly class VehicleAIVisionSettings_Record extends TweakDBRecord
{
	public import function NumSweeps() : Int32;
	public import function SideOverlapLongitudinalScale() : Float;
	public import function MaxStraightPathExtension() : Float;
	public import function OffsetSmoothingFastChangeSpeed() : Float;
	public import function SideOverlapLateralScale() : Float;
	public import function SideOverlapForwardOffset() : Float;
	public import function OffsetSmoothingReturnToNeutralSpeed() : Float;
	public import function MinDistance() : Float;
	public import function MaxDistance() : Float;
	public import function SpeedLimitSafetyMargin() : Float;
	public import function SpeedLimitDeceleration() : Float;
	public import function UseSpeedLimit() : Bool;
}

importonly class VehicleAirControl_Record extends TweakDBRecord
{
	public import function Yaw() : weak< VehicleAirControlAxis_Record >;
	public import function YawHandle() : VehicleAirControlAxis_Record;
	public import function Pitch() : weak< VehicleAirControlAxis_Record >;
	public import function PitchHandle() : VehicleAirControlAxis_Record;
	public import function Roll() : weak< VehicleAirControlAxis_Record >;
	public import function RollHandle() : VehicleAirControlAxis_Record;
	public import function AnglePID() : array< Float >;
	public import function GetAnglePIDCount() : Int32;
	public import function GetAnglePIDItem( index : Int32 ) : Float;
	public import function AnglePIDContains( item : Float ) : Bool;
	public import function VelocityPID() : array< Float >;
	public import function GetVelocityPIDCount() : Int32;
	public import function GetVelocityPIDItem( index : Int32 ) : Float;
	public import function VelocityPIDContains( item : Float ) : Bool;
	public import function FlippedOverRecoveryPID() : array< Float >;
	public import function GetFlippedOverRecoveryPIDCount() : Int32;
	public import function GetFlippedOverRecoveryPIDItem( index : Int32 ) : Float;
	public import function FlippedOverRecoveryPIDContains( item : Float ) : Bool;
	public import function MassReference() : Float;
}

importonly class VehicleAirControlAxis_Record extends TweakDBRecord
{
	public import function ControlAxis() : CName;
	public import function VelocityDampingThresholdMin() : Float;
	public import function AngleCorrectionThresholdMax() : Float;
	public import function VelocityDampingFactorMin() : Float;
	public import function VelocityDampFactor() : Float;
	public import function MaxVelocity() : Float;
	public import function InputDampFactor() : Float;
	public import function AngleCorrectionThresholdMin() : Float;
	public import function VelocityDampingFactorMax() : Float;
	public import function VelocityDampingThresholdMax() : Float;
	public import function AngleDampFactor() : Float;
	public import function BrakeMultiplierWhenNoInput() : Float;
	public import function AngleCorrectionFactorMin() : Float;
	public import function AngleCorrectionFactorMax() : Float;
	public import function MaxVelocityCompensation() : Float;
	public import function MaxAngleCompensation() : Float;
	public import function ZeroAngleThreshold() : Float;
	public import function MaxAngleToCompensateThreshold() : Float;
	public import function StabilizeAxis() : Bool;
}

importonly class VehicleBehaviorData_Record extends TweakDBRecord
{
	public import function ReadyToParkDistance() : Float;
}

importonly class VehicleBurnOut_Record extends TweakDBRecord
{
	public import function GripBonusMaxSpeedMultiplier() : Float;
	public import function LateralAccelForwardSpeedMaxDecimation() : Float;
	public import function BurnOutGripBonus() : Float;
	public import function LateralForceMaxAcceleration() : Float;
	public import function LateralForceMaxSpeed() : Float;
	public import function MaxLongFrictionSlipRatioMultipler() : Float;
	public import function MaxLateralAccelSlipRatioMultipler() : Float;
	public import function MaxSpeedToInitiateBurnOut() : Float;
	public import function MinLongFrictionCoeff() : Float;
	public import function LateralSlipRatioInfluence() : Float;
	public import function MinLongFrictionSlipRatioScaled() : Float;
	public import function GripBonusMaxLaunchSpeed() : Float;
	public import function MaxDriveWheelSlipRatio() : Float;
	public import function MinBrakeForceModifier() : Float;
	public import function MaxBrakeForceModifier() : Float;
}

importonly class VehicleCameraManager_Record extends TweakDBRecord
{
	public import function CamCollisionOBBIncrease() : Vector3;
	public import function CameraBlendTime() : Float;
	public import function AllowCameraReset() : Bool;
}

importonly class VehicleDataPackage_Record extends TweakDBRecord
{
	public import function DriverCombat() : weak< DriverCombatType_Record >;
	public import function DriverCombatHandle() : DriverCombatType_Record;
	public import function VehSeatSet() : weak< VehicleSeatSet_Record >;
	public import function VehSeatSetHandle() : VehicleSeatSet_Record;
	public import function AnimVars() : array< CName >;
	public import function GetAnimVarsCount() : Int32;
	public import function GetAnimVarsItem( index : Int32 ) : CName;
	public import function AnimVarsContains( item : CName ) : Bool;
	public import function AdditionalAnimFeatures() : array< CName >;
	public import function GetAdditionalAnimFeaturesCount() : Int32;
	public import function GetAdditionalAnimFeaturesItem( index : Int32 ) : CName;
	public import function AdditionalAnimFeaturesContains( item : CName ) : Bool;
	public import function BoneNames() : array< CName >;
	public import function GetBoneNamesCount() : Int32;
	public import function GetBoneNamesItem( index : Int32 ) : CName;
	public import function BoneNamesContains( item : CName ) : Bool;
	public import function FppCameraOverride() : CName;
	public import function SeatingTemplateOverride() : CName;
	public import function FromCombat() : Float;
	public import function ParkingAngle() : Float;
	public import function TireOnVehicleDamageImpulseScalor() : Float;
	public import function WheelBumperLengthScalor() : Float;
	public import function SpoilerSpeedToDeploy() : Float;
	public import function Stealing() : Float;
	public import function KnockOffForce() : Float;
	public import function ToCombat() : Float;
	public import function WheelBumperVertOffsetScalor() : Float;
	public import function SpeedToClose() : Float;
	public import function Entering() : Float;
	public import function SpoilerSpeedToRetract() : Float;
	public import function WheelBumperWidthScalor() : Float;
	public import function SlideDuration() : Float;
	public import function ExitDelay() : Float;
	public import function SwitchSeats() : Float;
	public import function CombatEntering() : Float;
	public import function Normal_open() : Float;
	public import function Stealing_open() : Float;
	public import function Open_close_duration() : Float;
	public import function Immediate_open_close_duration() : Float;
	public import function Body_dump_close_trunk_delay() : Float;
	public import function CanStoreBody() : Bool;
	public import function BarnDoorsTailgate() : Bool;
	public import function HasTurboCharger() : Bool;
	public import function HasSpoiler() : Bool;
	public import function UseAuxiliary() : Bool;
	public import function InteractiveTrunk() : Bool;
	public import function SlidingRearDoors() : Bool;
	public import function InteractiveHood() : Bool;
	public import function WindowsRollDown() : Bool;
	public import function DisableSwitchSeats() : Bool;
}

importonly class VehicleDefaultState_Record extends TweakDBRecord
{
	public import function Seat_front_left() : weak< SeatState_Record >;
	public import function Seat_front_leftHandle() : SeatState_Record;
	public import function Seat_front_right() : weak< SeatState_Record >;
	public import function Seat_front_rightHandle() : SeatState_Record;
	public import function Seat_back_left() : weak< SeatState_Record >;
	public import function Seat_back_leftHandle() : SeatState_Record;
	public import function Seat_back_right() : weak< SeatState_Record >;
	public import function Seat_back_rightHandle() : SeatState_Record;
	public import function Trunk() : weak< SeatState_Record >;
	public import function TrunkHandle() : SeatState_Record;
	public import function Hood() : weak< SeatState_Record >;
	public import function HoodHandle() : SeatState_Record;
	public import function LightToggleComponents() : array< Int32 >;
	public import function GetLightToggleComponentsCount() : Int32;
	public import function GetLightToggleComponentsItem( index : Int32 ) : Int32;
	public import function LightToggleComponentsContains( item : Int32 ) : Bool;
	public import function DisableAllInteractions() : Bool;
	public import function QuestLockAll() : Bool;
	public import function SpawnDestroyed() : Bool;
	public import function CloseAll() : Bool;
	public import function SirenLight() : Bool;
	public import function OpenAll() : Bool;
	public import function SirenSounds() : Bool;
	public import function DefaultLightToggle() : Bool;
	public import function Thrusters() : Bool;
	public import function LockAll() : Bool;
}

importonly class VehicleDeformablePart_Record extends TweakDBRecord
{
	public import function Zones( out outList : array< weak< VehicleDeformableZone_Record > > );
	public import function GetZonesCount() : Int32;
	public import function GetZonesItem( index : Int32 ) : weak< VehicleDeformableZone_Record >;
	public import function GetZonesItemHandle( index : Int32 ) : VehicleDeformableZone_Record;
	public import function ZonesContains( item : weak< VehicleDeformableZone_Record > ) : Bool;
	public import function Component() : CName;
}

importonly class VehicleDeformableZone_Record extends TweakDBRecord
{
	public import function Shapes() : array< Int32 >;
	public import function GetShapesCount() : Int32;
	public import function GetShapesItem( index : Int32 ) : Int32;
	public import function ShapesContains( item : Int32 ) : Bool;
	public import function GridCells() : array< Int32 >;
	public import function GetGridCellsCount() : Int32;
	public import function GetGridCellsItem( index : Int32 ) : Int32;
	public import function GridCellsContains( item : Int32 ) : Bool;
}

importonly class VehicleDestructibleGlass_Record extends TweakDBRecord
{
	public import function GridCells() : array< Int32 >;
	public import function GetGridCellsCount() : Int32;
	public import function GetGridCellsItem( index : Int32 ) : Int32;
	public import function GridCellsContains( item : Int32 ) : Bool;
	public import function Component() : CName;
	public import function Effect() : CName;
	public import function Broken() : CName;
	public import function Threshold() : Float;
	public import function IsWindshield() : Bool;
}

importonly class VehicleDestructibleLight_Record extends TweakDBRecord
{
	public import function GridCells() : array< Int32 >;
	public import function GetGridCellsCount() : Int32;
	public import function GetGridCellsItem( index : Int32 ) : Int32;
	public import function GridCellsContains( item : Int32 ) : Bool;
	public import function Component() : CName;
	public import function Threshold() : Float;
}

importonly class VehicleDestructibleWheel_Record extends TweakDBRecord
{
	public import function Name() : CName;
	public import function Flat() : CName;
	public import function Intact() : CName;
	public import function LinkedTire() : Int32;
	public import function HitsToFlatten() : Int32;
}

importonly class VehicleDestruction_Record extends TweakDBRecord
{
	public import function Glass( out outList : array< weak< VehicleDestructibleGlass_Record > > );
	public import function GetGlassCount() : Int32;
	public import function GetGlassItem( index : Int32 ) : weak< VehicleDestructibleGlass_Record >;
	public import function GetGlassItemHandle( index : Int32 ) : VehicleDestructibleGlass_Record;
	public import function GlassContains( item : weak< VehicleDestructibleGlass_Record > ) : Bool;
	public import function Lights( out outList : array< weak< VehicleDestructibleLight_Record > > );
	public import function GetLightsCount() : Int32;
	public import function GetLightsItem( index : Int32 ) : weak< VehicleDestructibleLight_Record >;
	public import function GetLightsItemHandle( index : Int32 ) : VehicleDestructibleLight_Record;
	public import function LightsContains( item : weak< VehicleDestructibleLight_Record > ) : Bool;
	public import function Wheels( out outList : array< weak< VehicleDestructibleWheel_Record > > );
	public import function GetWheelsCount() : Int32;
	public import function GetWheelsItem( index : Int32 ) : weak< VehicleDestructibleWheel_Record >;
	public import function GetWheelsItemHandle( index : Int32 ) : VehicleDestructibleWheel_Record;
	public import function WheelsContains( item : weak< VehicleDestructibleWheel_Record > ) : Bool;
	public import function DetachableParts( out outList : array< weak< VehicleDetachablePart_Record > > );
	public import function GetDetachablePartsCount() : Int32;
	public import function GetDetachablePartsItem( index : Int32 ) : weak< VehicleDetachablePart_Record >;
	public import function GetDetachablePartsItemHandle( index : Int32 ) : VehicleDetachablePart_Record;
	public import function DetachablePartsContains( item : weak< VehicleDetachablePart_Record > ) : Bool;
	public import function PointDampers( out outList : array< weak< VehicleDestructionPointDamper_Record > > );
	public import function GetPointDampersCount() : Int32;
	public import function GetPointDampersItem( index : Int32 ) : weak< VehicleDestructionPointDamper_Record >;
	public import function GetPointDampersItemHandle( index : Int32 ) : VehicleDestructionPointDamper_Record;
	public import function PointDampersContains( item : weak< VehicleDestructionPointDamper_Record > ) : Bool;
	public import function DeformableParts( out outList : array< weak< VehicleDeformablePart_Record > > );
	public import function GetDeformablePartsCount() : Int32;
	public import function GetDeformablePartsItem( index : Int32 ) : weak< VehicleDeformablePart_Record >;
	public import function GetDeformablePartsItemHandle( index : Int32 ) : VehicleDeformablePart_Record;
	public import function DeformablePartsContains( item : weak< VehicleDeformablePart_Record > ) : Bool;
	public import function DoorDetachRules( out outList : array< weak< VehicleDoorDetachRule_Record > > );
	public import function GetDoorDetachRulesCount() : Int32;
	public import function GetDoorDetachRulesItem( index : Int32 ) : weak< VehicleDoorDetachRule_Record >;
	public import function GetDoorDetachRulesItemHandle( index : Int32 ) : VehicleDoorDetachRule_Record;
	public import function DoorDetachRulesContains( item : weak< VehicleDoorDetachRule_Record > ) : Bool;
	public import function DetachedPartExplosionEffect() : ResRef;
	public import function VehicleDimensions() : Vector3;
	public import function ChargePortCenter() : Vector3;
	public import function GridDimensions() : Vector3;
	public import function GridLocalOffset() : Vector3;
	public import function DamageThreshold() : Float;
	public import function VelocityValueMinDamage() : Float;
	public import function DamageExponent() : Float;
	public import function ForcePropagationFalloff() : Float;
	public import function VelocityValueMaxDamage() : Float;
	public import function ChargePortRadius() : Float;
	public import function OnHitVelocity() : Float;
	public import function EnableOnHit() : Bool;
}

importonly class VehicleDestructionPointDamper_Record extends TweakDBRecord
{
	public import function PointIndex() : Int32;
	public import function DampValue() : Float;
	public import function PointFragility() : Float;
}

importonly class VehicleDetachablePart_Record extends TweakDBRecord
{
	public import function Components() : array< CName >;
	public import function GetComponentsCount() : Int32;
	public import function GetComponentsItem( index : Int32 ) : CName;
	public import function ComponentsContains( item : CName ) : Bool;
	public import function GridCells() : array< Int32 >;
	public import function GetGridCellsCount() : Int32;
	public import function GetGridCellsItem( index : Int32 ) : Int32;
	public import function GridCellsContains( item : Int32 ) : Bool;
	public import function Name() : CName;
	public import function Threshold() : Float;
	public import function SpawnsExplosionEffect() : Bool;
}

importonly class VehicleDiscountSettings_Record extends TweakDBRecord
{
	public import function DiscountValues() : array< Float >;
	public import function GetDiscountValuesCount() : Int32;
	public import function GetDiscountValuesItem( index : Int32 ) : Float;
	public import function DiscountValuesContains( item : Float ) : Bool;
	public import function DiscountFact() : CName;
}

importonly class VehicleDoorDetachRule_Record extends TweakDBRecord
{
	public import function PartsToDetach() : array< CName >;
	public import function GetPartsToDetachCount() : Int32;
	public import function GetPartsToDetachItem( index : Int32 ) : CName;
	public import function PartsToDetachContains( item : CName ) : Bool;
	public import function ComponentToQuery() : CName;
	public import function DoorEnumIndex() : Int32;
}

importonly class VehicleDriveModelData_Record extends TweakDBRecord
{
	public import function WaterParams() : weak< VehicleWater_Record >;
	public import function WaterParamsHandle() : VehicleWater_Record;
	public import function WheelSetup() : weak< VehicleWheelDrivingSetup_Record >;
	public import function WheelSetupHandle() : VehicleWheelDrivingSetup_Record;
	public import function WheelsFrictionMap() : weak< VehicleWheelsFrictionMap_Record >;
	public import function WheelsFrictionMapHandle() : VehicleWheelsFrictionMap_Record;
	public import function BurnOut() : weak< VehicleBurnOut_Record >;
	public import function BurnOutHandle() : VehicleBurnOut_Record;
	public import function FlatTireSim() : weak< VehicleFlatTireSimulation_Record >;
	public import function FlatTireSimHandle() : VehicleFlatTireSimulation_Record;
	public import function DriveHelpers( out outList : array< weak< DriveHelper_Record > > );
	public import function GetDriveHelpersCount() : Int32;
	public import function GetDriveHelpersItem( index : Int32 ) : weak< DriveHelper_Record >;
	public import function GetDriveHelpersItemHandle( index : Int32 ) : DriveHelper_Record;
	public import function DriveHelpersContains( item : weak< DriveHelper_Record > ) : Bool;
	public import function Center_of_mass_offset() : Vector3;
	public import function MomentOfInertia() : Vector3;
	public import function MomentOfInertiaScale() : Vector3;
	public import function SlopeTractionReductionBegin() : Float;
	public import function TurnUpdateInputDiffForSlowChange() : Float;
	public import function SideWeightTransferFactor() : Float;
	public import function TurnUpdateInputDiffForFastChange() : Float;
	public import function TurnUpdateMidSpeedTurnMul() : Float;
	public import function AirResistanceFactor() : Float;
	public import function TurnUpdateBaseSpeedThreshold() : Float;
	public import function TurnUpdateMaxSpeedTurnChangeMul() : Float;
	public import function Total_mass() : Float;
	public import function TurnUpdateInputSlowChangeSpeed() : Float;
	public import function ForwardWeightTransferFactor() : Float;
	public import function BankBodyFBTanMultiplier() : Float;
	public import function TurnUpdateInputDiffProgressionPow() : Float;
	public import function MaxWheelTurnDeg() : Float;
	public import function TurnUpdateMidSpeedTurnChangeMul() : Float;
	public import function BodyFriction() : Float;
	public import function TurningRollFactorWeakContactMul() : Float;
	public import function BankBodyLRTanMultiplier() : Float;
	public import function SmoothWheelContactDecreaseTime() : Float;
	public import function TurningRollFactorWeakContactThresholdMax() : Float;
	public import function PerfectSteeringFactor() : Float;
	public import function TurningRollFactor() : Float;
	public import function TurnUpdateMaxSpeedTurnMul() : Float;
	public import function TurnUpdateInputFastChangeSpeed() : Float;
	public import function WheelTurnMaxAddPerSecond() : Float;
	public import function SlopeTractionReductionMax() : Float;
	public import function AntiSwaybarDampingScalor() : Float;
	public import function TurnUpdateMaxSpeedThreshold() : Float;
	public import function LowVelStoppingDeceleration() : Float;
	public import function TurningRollFactorWeakContactThresholdMin() : Float;
	public import function HandbrakeBrakingTorque() : Float;
	public import function WheelTurnMaxSubPerSecond() : Float;
	public import function SlopeTractionReductionFactor() : Float;
	public import function Chassis_mass() : Float;
	public import function SmoothWheelContactIncreseTime() : Float;
	public import function TurnUpdateMidSpeedThreshold() : Float;
	public import function BrakingFrictionFactor() : Float;
	public import function DifferentialOvershootFactor() : Float;
	public import function SlipAngleMinSpeedThreshold() : Float;
	public import function SlipAngleCurveScale() : Float;
	public import function SlipRatioMinSpeedThreshold() : Float;
	public import function SlipRatioCurveScale() : Float;
	public import function BrakingEstimationMagicFactor() : Float;
	public import function UseAlternativeTurnUpdate() : Bool;
}

importonly class VehicleEngineData_Record extends TweakDBRecord
{
	public import function Gears( out outList : array< weak< VehicleGear_Record > > );
	public import function GetGearsCount() : Int32;
	public import function GetGearsItem( index : Int32 ) : weak< VehicleGear_Record >;
	public import function GetGearsItemHandle( index : Int32 ) : VehicleGear_Record;
	public import function GearsContains( item : weak< VehicleGear_Record > ) : Bool;
	public import function GearCurvesPath() : ResRef;
	public import function FinalGearTorqueDecimationScalor() : Float;
	public import function GearChangeCooldown() : Float;
	public import function ReverseDirDelay() : Float;
	public import function MinRPM() : Float;
	public import function WheelsResistanceRatio() : Float;
	public import function FlyWheelMomentOfInertia() : Float;
	public import function EngineMaxTorque() : Float;
	public import function ResistanceTorque() : Float;
	public import function MaxRPM() : Float;
	public import function GearChangeTime() : Float;
	public import function FastR1GearChange() : Bool;
	public import function ForceReverseRPMToMin() : Bool;
}

importonly class VehicleFPPCameraParams_Record extends TweakDBRecord
{
	public import function Rear_view_offset() : Vector3;
	public import function Is_pitch_off() : Float;
	public import function Paralax_radius() : Float;
	public import function Lookat_yaw_left_up_offset() : Float;
	public import function Lookat_offset_vertical() : Float;
	public import function Upperbody_yaw_weight() : Float;
	public import function Lookat_yaw_right_up_offset() : Float;
	public import function Is_paralax() : Float;
	public import function Is_yaw_off() : Float;
	public import function Lookat_yaw_left_offset() : Float;
	public import function Lookat_yaw_offset_active_angle() : Float;
	public import function Lookat_yaw_right_offset() : Float;
	public import function Is_forward_offset() : Float;
	public import function Lookat_pitch_forward_down_ratio() : Float;
	public import function Upperbody_pitch_weight() : Float;
	public import function Paralax_forward_offset() : Float;
	public import function Lookat_pitch_forward_offset() : Float;
	public import function Forward_offset_value() : Float;
	public import function Rear_view_yaw_threshold() : Float;
	public import function Rear_view_pitch_threshold() : Float;
	public import function Enable_rear_view() : Bool;
}

importonly class VehicleFlatTireSimParams_Record extends TweakDBRecord
{
	public import function LateralFrictionDecimation() : Float;
	public import function LongitudinalFrictionDecimation() : Float;
	public import function RotationResistanceTorque() : Float;
	public import function BlowOutImpulse() : Float;
}

importonly class VehicleFlatTireSimulation_Record extends TweakDBRecord
{
	public import function Front() : weak< VehicleFlatTireSimParams_Record >;
	public import function FrontHandle() : VehicleFlatTireSimParams_Record;
	public import function Rear() : weak< VehicleFlatTireSimParams_Record >;
	public import function RearHandle() : VehicleFlatTireSimParams_Record;
}

importonly class VehicleFxCollision_Record extends TweakDBRecord
{
	public import function Materials( out outList : array< weak< VehicleFxCollisionMaterial_Record > > );
	public import function GetMaterialsCount() : Int32;
	public import function GetMaterialsItem( index : Int32 ) : weak< VehicleFxCollisionMaterial_Record >;
	public import function GetMaterialsItemHandle( index : Int32 ) : VehicleFxCollisionMaterial_Record;
	public import function MaterialsContains( item : weak< VehicleFxCollisionMaterial_Record > ) : Bool;
}

importonly class VehicleFxCollisionMaterial_Record extends TweakDBRecord
{
	public import function Material() : weak< Material_Record >;
	public import function MaterialHandle() : Material_Record;
	public import function Impact_decal() : ResRef;
	public import function Scratch_particles() : ResRef;
	public import function Impact_particles() : ResRef;
	public import function Scratch_decal() : ResRef;
}

importonly class VehicleFxWheelsDecals_Record extends TweakDBRecord
{
	public import function Materials( out outList : array< weak< VehicleFxWheelsDecalsMaterial_Record > > );
	public import function GetMaterialsCount() : Int32;
	public import function GetMaterialsItem( index : Int32 ) : weak< VehicleFxWheelsDecalsMaterial_Record >;
	public import function GetMaterialsItemHandle( index : Int32 ) : VehicleFxWheelsDecalsMaterial_Record;
	public import function MaterialsContains( item : weak< VehicleFxWheelsDecalsMaterial_Record > ) : Bool;
	public import function Wet_material_overrides( out outList : array< weak< VehicleFxWheelsDecalsMaterial_Record > > );
	public import function GetWet_material_overridesCount() : Int32;
	public import function GetWet_material_overridesItem( index : Int32 ) : weak< VehicleFxWheelsDecalsMaterial_Record >;
	public import function GetWet_material_overridesItemHandle( index : Int32 ) : VehicleFxWheelsDecalsMaterial_Record;
	public import function Wet_material_overridesContains( item : weak< VehicleFxWheelsDecalsMaterial_Record > ) : Bool;
	public import function Rain_material_overrides( out outList : array< weak< VehicleFxWheelsDecalsMaterial_Record > > );
	public import function GetRain_material_overridesCount() : Int32;
	public import function GetRain_material_overridesItem( index : Int32 ) : weak< VehicleFxWheelsDecalsMaterial_Record >;
	public import function GetRain_material_overridesItemHandle( index : Int32 ) : VehicleFxWheelsDecalsMaterial_Record;
	public import function Rain_material_overridesContains( item : weak< VehicleFxWheelsDecalsMaterial_Record > ) : Bool;
	public import function Smear_materials( out outList : array< weak< VehicleFxWheelsDecalsMaterialSmear_Record > > );
	public import function GetSmear_materialsCount() : Int32;
	public import function GetSmear_materialsItem( index : Int32 ) : weak< VehicleFxWheelsDecalsMaterialSmear_Record >;
	public import function GetSmear_materialsItemHandle( index : Int32 ) : VehicleFxWheelsDecalsMaterialSmear_Record;
	public import function Smear_materialsContains( item : weak< VehicleFxWheelsDecalsMaterialSmear_Record > ) : Bool;
}

importonly class VehicleFxWheelsDecalsMaterial_Record extends TweakDBRecord
{
	public import function Material() : weak< Material_Record >;
	public import function MaterialHandle() : Material_Record;
	public import function Skid_marks_decal() : ResRef;
	public import function Tire_tracks_decal() : ResRef;
}

importonly class VehicleFxWheelsDecalsMaterialSmear_Record extends VehicleFxWheelsDecalsMaterial_Record
{
	public import function Distance() : Float;
}

importonly class VehicleFxWheelsParticles_Record extends TweakDBRecord
{
	public import function Materials( out outList : array< weak< VehicleFxWheelsParticlesMaterial_Record > > );
	public import function GetMaterialsCount() : Int32;
	public import function GetMaterialsItem( index : Int32 ) : weak< VehicleFxWheelsParticlesMaterial_Record >;
	public import function GetMaterialsItemHandle( index : Int32 ) : VehicleFxWheelsParticlesMaterial_Record;
	public import function MaterialsContains( item : weak< VehicleFxWheelsParticlesMaterial_Record > ) : Bool;
	public import function Wet_material_overrides( out outList : array< weak< VehicleFxWheelsParticlesMaterial_Record > > );
	public import function GetWet_material_overridesCount() : Int32;
	public import function GetWet_material_overridesItem( index : Int32 ) : weak< VehicleFxWheelsParticlesMaterial_Record >;
	public import function GetWet_material_overridesItemHandle( index : Int32 ) : VehicleFxWheelsParticlesMaterial_Record;
	public import function Wet_material_overridesContains( item : weak< VehicleFxWheelsParticlesMaterial_Record > ) : Bool;
	public import function Rain_material_overrides( out outList : array< weak< VehicleFxWheelsParticlesMaterial_Record > > );
	public import function GetRain_material_overridesCount() : Int32;
	public import function GetRain_material_overridesItem( index : Int32 ) : weak< VehicleFxWheelsParticlesMaterial_Record >;
	public import function GetRain_material_overridesItemHandle( index : Int32 ) : VehicleFxWheelsParticlesMaterial_Record;
	public import function Rain_material_overridesContains( item : weak< VehicleFxWheelsParticlesMaterial_Record > ) : Bool;
}

importonly class VehicleFxWheelsParticlesMaterial_Record extends TweakDBRecord
{
	public import function Material() : weak< Material_Record >;
	public import function MaterialHandle() : Material_Record;
	public import function Skid_marks_particles() : ResRef;
	public import function Tire_tracks_particles() : ResRef;
}

importonly class VehicleGear_Record extends TweakDBRecord
{
	public import function MaxSpeed() : Float;
	public import function MaxEngineRPM() : Float;
	public import function MinSpeed() : Float;
	public import function MinEngineRPM() : Float;
	public import function TorqueMultiplier() : Float;
}

importonly class VehicleImpactTraffic_Record extends TweakDBRecord
{
	public import function MinThreshold() : Float;
	public import function MaxThreshold() : Float;
	public import function MaxTimerStunned() : Float;
}

importonly class VehicleManufacturer_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataVehicleManufacturer;
}

importonly class VehicleModel_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataVehicleModel;
}

importonly class VehicleOffer_Record extends PurchaseOffer_Record
{
	public import function Description() : String;
	public import function UnlockType() : weak< VehicleUnlockType_Record >;
	public import function UnlockTypeHandle() : VehicleUnlockType_Record;
	public import function AvailabilityFact() : CName;
	public import function BrandName() : CName;
	public import function OwnershipFact() : CName;
	public import function HasRocketLauncher() : Bool;
	public import function DiscountApplicable() : Bool;
	public import function HasMachineGun() : Bool;
}

importonly class VehiclePIDSettings_Record extends TweakDBRecord
{
	public import function I() : Float;
	public import function P() : Float;
	public import function OutputSaturationLimit() : Float;
	public import function D() : Float;
	public import function IntegratorClampingLimit() : Float;
}

importonly class VehicleProceduralFPPCameraParams_Record extends TweakDBRecord
{
	public import function ImpactThreshold() : Float;
	public import function DisplacementThresholdForward() : Float;
	public import function MaxDisplacementDown() : Float;
	public import function ForwardDampFactor() : Float;
	public import function MaxAccelerationTiltAngle() : Float;
	public import function SteeringAngleRight() : Float;
	public import function MaxDisplacementUp() : Float;
	public import function DirectionFollowMaxVelocity() : Float;
	public import function MaxDisplacementRight() : Float;
	public import function MaxDisplacementLeft() : Float;
	public import function HeightDampFactor() : Float;
	public import function MaxDisplacementBackward() : Float;
	public import function ImpactDamperDampFactor() : Float;
	public import function MaxSlowdownTiltAngle() : Float;
	public import function SteeringDampFactor() : Float;
	public import function SideDampFactor() : Float;
	public import function SteeringAngleLeft() : Float;
	public import function SmoothSpeedDampFactor() : Float;
	public import function MaxDisplacementForward() : Float;
	public import function ImpactBlendSpeed() : Float;
	public import function ImpactStrengthCoef() : Float;
	public import function MaxRollCorrection() : Float;
	public import function MaxPitchCorrectionUP() : Float;
	public import function MaxPitchCorrectionDown() : Float;
	public import function RollCorrectionDampFactor() : Float;
	public import function PitchCorrectionDampFactor() : Float;
}

importonly class VehicleSeat_Record extends TweakDBRecord
{
	public import function SeatName() : CName;
}

importonly class VehicleSeatSet_Record extends TweakDBRecord
{
	public import function VehSeats( out outList : array< weak< VehicleSeat_Record > > );
	public import function GetVehSeatsCount() : Int32;
	public import function GetVehSeatsItem( index : Int32 ) : weak< VehicleSeat_Record >;
	public import function GetVehSeatsItemHandle( index : Int32 ) : VehicleSeat_Record;
	public import function VehSeatsContains( item : weak< VehicleSeat_Record > ) : Bool;
}

importonly class VehicleSteeringSettings_Record extends TweakDBRecord
{
	public import function VehicleMinTurnSpeed() : Float;
	public import function SpeedForMinDistance() : Float;
	public import function FullSteeringSpeed() : Float;
	public import function ErrorMagnitudeForMildSteering() : Float;
	public import function MildSteeringSpeed() : Float;
	public import function ErrorMagnitudeForFullSteering() : Float;
	public import function SpeedForMaxDistance() : Float;
	public import function MaxTargetDistance() : Float;
	public import function MinTargetDistance() : Float;
	public import function VehicleMaxTurnSpeed() : Float;
	public import function IncreaseSteeringDistForAvoidance() : Bool;
}

importonly class VehicleStoppingSettings_Record extends TweakDBRecord
{
	public import function MildBrakingChangeSpeed() : Float;
	public import function ErrorMagnitudeForMildBrakingChange() : Float;
	public import function FullBrakingChangeSpeed() : Float;
	public import function ErrorMagnitudeForFullBrakingChange() : Float;
	public import function DecreaseMul() : Float;
}

importonly class VehicleSurfaceBinding_Record extends TweakDBRecord
{
	public import function SurfaceType() : weak< VehicleSurfaceType_Record >;
	public import function SurfaceTypeHandle() : VehicleSurfaceType_Record;
	public import function FrictionPreset() : weak< VehicleWheelsFrictionPreset_Record >;
	public import function FrictionPresetHandle() : VehicleWheelsFrictionPreset_Record;
}

importonly class VehicleSurfaceType_Record extends TweakDBRecord
{
	public import function DisplayName() : String;
	public import function MaterialNames() : array< CName >;
	public import function GetMaterialNamesCount() : Int32;
	public import function GetMaterialNamesItem( index : Int32 ) : CName;
	public import function MaterialNamesContains( item : CName ) : Bool;
}

importonly class VehicleTPPCameraParams_Record extends TweakDBRecord
{
	public import function Fov() : Float;
	public import function SlopeCorrectionOnGroundPitchMin() : Float;
	public import function AutoCenterMaxSpeedThreshold() : Float;
	public import function CameraSphereRadius() : Float;
	public import function DrivingDirectionCompensationSpeedCoef() : Float;
	public import function CameraMinPitch() : Float;
	public import function SlopeCorrectionInAirPitchMin() : Float;
	public import function SlopeCorrectionInAirDampFactor() : Float;
	public import function SlopeCorrectionInAirPitchMax() : Float;
	public import function ElasticBoomForwardAccelerationCoef() : Float;
	public import function CameraBoomExtensionSpeed() : Float;
	public import function DrivingDirectionCompensationAngle() : Float;
	public import function SlopeCorrectionOnGroundStrength() : Float;
	public import function ElasticBoomSpeedExpansionLength() : Float;
	public import function AutoCenterSpeed() : Float;
	public import function DrivingDirectionCompensationAngularVelocityMin() : Float;
	public import function SlopeCorrectionInAirSpeedMax() : Float;
	public import function ElasticBoomSpeedExpansionSpeedMin() : Float;
	public import function SlopeCorrectionInAirRaiseCoef() : Float;
	public import function DrivingDirectionCompensationAngleSmooth() : Float;
	public import function ElasticBoomSpeedExpansionSpeedMax() : Float;
	public import function ElasticBoomAccelerationExpansionLength() : Float;
	public import function SlopeCorrectionInAirFallCoef() : Float;
	public import function CameraMaxPitch() : Float;
	public import function SlopeCorrectionInAirStrength() : Float;
	public import function DrivingDirectionCompensationSpeedMax() : Float;
	public import function DrivingDirectionCompensationSpeedMin() : Float;
	public import function SlopeCorrectionOnGroundPitchMax() : Float;
	public import function InverseCameraInputBreakThreshold() : Float;
	public import function HeadLookAtMaxYaw() : Float;
	public import function HeadLookAtCenterYawThreshold() : Float;
	public import function HeadLookAtMaxPitchUp() : Float;
	public import function HeadLookAtMaxPitchDown() : Float;
	public import function HeadLookAtRotationSpeed() : Float;
	public import function CollisionDetection() : Bool;
	public import function ElasticBoomVelocity() : Bool;
	public import function ElasticBoomAcceleration() : Bool;
	public import function DrivingDirectionCompensation() : Bool;
	public import function SlopeAdjustement() : Bool;
	public import function AirFlowDistortion() : Bool;
	public import function LockedCamera() : Bool;
}

importonly class VehicleTPPCameraPresetParams_Record extends TweakDBRecord
{
	public import function Height() : CName;
	public import function Distance() : CName;
	public import function LookAtOffset() : Vector3;
	public import function DefaultRotationPitch() : Float;
	public import function BoomLengthOffset() : Float;
	public import function BaseBoomLength() : Float;
	public import function AirFlowDistortionSizeHorizontal() : Float;
	public import function AirFlowDistortionSpeedMin() : Float;
	public import function AirFlowDistortionSpeedMax() : Float;
	public import function AirFlowDistortionSizeVertical() : Float;
}

importonly class VehicleTrafficSuspension_Record extends TweakDBRecord
{
	public import function LongDampingRatio() : Float;
	public import function LongPeriod() : Float;
	public import function LatDampingRatio() : Float;
	public import function LatPeriod() : Float;
}

importonly class VehicleType_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataVehicleType;
}

importonly class VehicleUIData_Record extends TweakDBRecord
{
	public import function DriveLayout() : String;
	public import function ProductionYear() : String;
	public import function Info() : String;
	public import function Mass() : Float;
	public import function Horsepower() : Float;
}

importonly class VehicleUnlockType_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function EnumComment() : String;
	public import function Type() : gamedataVehicleUnlockType;
}

importonly class VehicleVisualDestruction_Record extends TweakDBRecord
{
	public import function Left() : Float;
	public import function BackRight() : Float;
	public import function FrontLeft() : Float;
	public import function BackLeft() : Float;
	public import function Front() : Float;
	public import function Right() : Float;
	public import function Back() : Float;
	public import function FrontRight() : Float;
	public import function Roof() : Float;
	public import function SetVisualDestruction() : Bool;
}

importonly class VehicleWater_Record extends TweakDBRecord
{
	public import function Vfx_impact_water() : ResRef;
	public import function ParamVehicleSpeed() : CName;
	public import function BuoyancyCoef() : Float;
	public import function LinearDampingCoef() : Float;
	public import function ImpulseOverhangDistance() : Float;
	public import function ImpulseStrengthFallMultiplierMin() : Float;
	public import function MinSpeedToApplyImpulses() : Float;
	public import function ImpulseStrength() : Float;
	public import function SubmergedThreshold() : Float;
	public import function MinDistanceBetweenImpulses() : Float;
	public import function MaxVehicleSpeed() : Float;
	public import function ImpulseRadius() : Float;
	public import function AngularDampingCoef() : Float;
	public import function ImpulseStrengthFallMultiplierMax() : Float;
	public import function VerticalVelocityThresholdForFallFx() : Float;
	public import function DepthThresholdForFallFx() : Float;
	public import function MinDistanceBetweenFx() : Float;
	public import function DisableAirControl() : Bool;
	public import function DisableEngine() : Bool;
}

importonly class VehicleWeapon_Record extends TweakDBRecord
{
	public import function Slot() : weak< AttachmentSlot_Record >;
	public import function SlotHandle() : AttachmentSlot_Record;
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
	public import function WeaponShootAnimEvent() : CName;
	public import function MinYaw() : Float;
	public import function MaxYaw() : Float;
	public import function MaxPitch() : Float;
	public import function CycleTime() : Float;
	public import function AttackRange() : Float;
	public import function SingleShotProjectiles() : Int32;
	public import function SingleProjectileCycleTime() : Float;
	public import function WholeBurstProjectiles() : Int32;
	public import function Spread() : Float;
	public import function MinPitch() : Float;
	public import function GenericTick() : Bool;
	public import function GenericShoot() : Bool;
	public import function CanFriendlyFire() : Bool;
}

importonly class VehicleWheelDimensionsPreset_Record extends TweakDBRecord
{
	public import function TireRadius() : Float;
	public import function RimRadius() : Float;
	public import function TireWidth() : Float;
	public import function WheelOffset() : Float;
}

importonly class VehicleWheelDimensionsSetup_Record extends TweakDBRecord
{
	public import function FrontPreset() : weak< VehicleWheelDimensionsPreset_Record >;
	public import function FrontPresetHandle() : VehicleWheelDimensionsPreset_Record;
	public import function BackPreset() : weak< VehicleWheelDimensionsPreset_Record >;
	public import function BackPresetHandle() : VehicleWheelDimensionsPreset_Record;
}

importonly class VehicleWheelDrivingPreset_Record extends TweakDBRecord
{
	public import function TireLongitudinalSlipEffectsMul() : Float;
	public import function TireRollingResistanceCoef() : Float;
	public import function Mass() : Float;
	public import function SwaybarDisplacementLimit() : Float;
	public import function TireFrictionCoef() : Float;
	public import function TireLateralSlipEffectsMul() : Float;
	public import function MaxBrakingTorque() : Float;
	public import function SpringDampingLowRateCompression() : Float;
	public import function SpringReboundDamping() : Float;
	public import function SpringBoundDampingLowRate() : Float;
	public import function ExtremeCompressionEventScalor() : Float;
	public import function SpringDampingHighRateCompression() : Float;
	public import function SwaybarStiffness() : Float;
	public import function SpringDamping() : Float;
	public import function FrictionMulLongitudinal() : Float;
	public import function FrictionMulLateral() : Float;
	public import function SwaybarLengthScalar() : Float;
	public import function SpringReboundDampingLowRate() : Float;
	public import function SpringStiffness() : Float;
	public import function VisualSuspensionDroop() : Float;
	public import function LogicalSuspensionCompressionLength() : Float;
	public import function VisualSuspensionCompressionLength() : Float;
	public import function TenderSpringLength() : Float;
	public import function WheelsVerticalOffset() : Float;
}

importonly class VehicleWheelDrivingSetup_Record extends TweakDBRecord
{
	public import function FrontPreset() : weak< VehicleWheelDrivingPreset_Record >;
	public import function FrontPresetHandle() : VehicleWheelDrivingPreset_Record;
	public import function BackPreset() : weak< VehicleWheelDrivingPreset_Record >;
	public import function BackPresetHandle() : VehicleWheelDrivingPreset_Record;
}

importonly class VehicleWheelDrivingSetup_2_Record extends VehicleWheelDrivingSetup_Record
{
	public import function F() : weak< VehicleWheelRole_Record >;
	public import function FHandle() : VehicleWheelRole_Record;
	public import function B() : weak< VehicleWheelRole_Record >;
	public import function BHandle() : VehicleWheelRole_Record;
}

importonly class VehicleWheelDrivingSetup_4_Record extends VehicleWheelDrivingSetup_Record
{
	public import function RF() : weak< VehicleWheelRole_Record >;
	public import function RFHandle() : VehicleWheelRole_Record;
	public import function RB() : weak< VehicleWheelRole_Record >;
	public import function RBHandle() : VehicleWheelRole_Record;
	public import function LF() : weak< VehicleWheelRole_Record >;
	public import function LFHandle() : VehicleWheelRole_Record;
	public import function LB() : weak< VehicleWheelRole_Record >;
	public import function LBHandle() : VehicleWheelRole_Record;
}

importonly class VehicleWheelRole_Record extends TweakDBRecord
{
	public import function IsDrive() : Bool;
	public import function IsMainBrake() : Bool;
	public import function IsHandBrake() : Bool;
}

importonly class VehicleWheelsFrictionMap_Record extends TweakDBRecord
{
	public import function DefaultFrictionPreset() : weak< VehicleWheelsFrictionPreset_Record >;
	public import function DefaultFrictionPresetHandle() : VehicleWheelsFrictionPreset_Record;
	public import function Surfaces( out outList : array< weak< VehicleSurfaceBinding_Record > > );
	public import function GetSurfacesCount() : Int32;
	public import function GetSurfacesItem( index : Int32 ) : weak< VehicleSurfaceBinding_Record >;
	public import function GetSurfacesItemHandle( index : Int32 ) : VehicleSurfaceBinding_Record;
	public import function SurfacesContains( item : weak< VehicleSurfaceBinding_Record > ) : Bool;
}

importonly class VehicleWheelsFrictionPreset_Record extends TweakDBRecord
{
	public import function DisplayName() : String;
	public import function FrictionCurveSet() : ResRef;
	public import function LooseSurfaceLongDriveResistanceCoeff() : Float;
	public import function LooseSurfaceLongSpeedMax() : Float;
	public import function LooseSurfaceLatSpeedMax() : Float;
	public import function FrictionLongMultiplier() : Float;
	public import function LooseSurfaceLatResistanceCoeff() : Float;
	public import function LooseSurfaceLongNonDriveResistanceCoeff() : Float;
	public import function FrictionLatMultiplier() : Float;
	public import function AudioMaterialCoeff() : Float;
}

importonly class Vendor_Record extends TweakDBRecord
{
	public import function LocalizedDescription() : String;
	public import function LocalizedName() : String;
	public import function Faction() : weak< Affiliation_Record >;
	public import function FactionHandle() : Affiliation_Record;
	public import function VendorType() : weak< VendorType_Record >;
	public import function VendorTypeHandle() : VendorType_Record;
	public import function VendorFilterTags() : array< CName >;
	public import function GetVendorFilterTagsCount() : Int32;
	public import function GetVendorFilterTagsItem( index : Int32 ) : CName;
	public import function VendorFilterTagsContains( item : CName ) : Bool;
	public import function ItemStock( out outList : array< weak< VendorItem_Record > > );
	public import function GetItemStockCount() : Int32;
	public import function GetItemStockItem( index : Int32 ) : weak< VendorItem_Record >;
	public import function GetItemStockItemHandle( index : Int32 ) : VendorItem_Record;
	public import function ItemStockContains( item : weak< VendorItem_Record > ) : Bool;
	public import function ExperienceStock( out outList : array< weak< VendorExperience_Record > > );
	public import function GetExperienceStockCount() : Int32;
	public import function GetExperienceStockItem( index : Int32 ) : weak< VendorExperience_Record >;
	public import function GetExperienceStockItemHandle( index : Int32 ) : VendorExperience_Record;
	public import function ExperienceStockContains( item : weak< VendorExperience_Record > ) : Bool;
	public import function VendorInverseFilterTags() : array< CName >;
	public import function GetVendorInverseFilterTagsCount() : Int32;
	public import function GetVendorInverseFilterTagsItem( index : Int32 ) : CName;
	public import function VendorInverseFilterTagsContains( item : CName ) : Bool;
	public import function CustomerInverseFilterTags() : array< CName >;
	public import function GetCustomerInverseFilterTagsCount() : Int32;
	public import function GetCustomerInverseFilterTagsItem( index : Int32 ) : CName;
	public import function CustomerInverseFilterTagsContains( item : CName ) : Bool;
	public import function CustomerFilterTags() : array< CName >;
	public import function GetCustomerFilterTagsCount() : Int32;
	public import function GetCustomerFilterTagsItem( index : Int32 ) : CName;
	public import function CustomerFilterTagsContains( item : CName ) : Bool;
	public import function ItemQueries( out outList : array< weak< VendorItemQuery_Record > > );
	public import function GetItemQueriesCount() : Int32;
	public import function GetItemQueriesItem( index : Int32 ) : weak< VendorItemQuery_Record >;
	public import function GetItemQueriesItemHandle( index : Int32 ) : VendorItemQuery_Record;
	public import function ItemQueriesContains( item : weak< VendorItemQuery_Record > ) : Bool;
	public import function MapVisibilityPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetMapVisibilityPrereqsCount() : Int32;
	public import function GetMapVisibilityPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetMapVisibilityPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function MapVisibilityPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function AccessPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetAccessPrereqsCount() : Int32;
	public import function GetAccessPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetAccessPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function AccessPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function Craftbooks( out outList : array< weak< VendorCraftable_Record > > );
	public import function GetCraftbooksCount() : Int32;
	public import function GetCraftbooksItem( index : Int32 ) : weak< VendorCraftable_Record >;
	public import function GetCraftbooksItemHandle( index : Int32 ) : VendorCraftable_Record;
	public import function CraftbooksContains( item : weak< VendorCraftable_Record > ) : Bool;
	public import function InGameTimeToRestock() : Float;
}

importonly class VendorCraftable_Record extends VendorWare_Record
{
	public import function Craftbook() : weak< Craftable_Record >;
	public import function CraftbookHandle() : Craftable_Record;
}

importonly class VendorExperience_Record extends VendorWare_Record
{
	public import function Proficiency() : weak< Proficiency_Record >;
	public import function ProficiencyHandle() : Proficiency_Record;
	public import function PricePerPoint( out outList : array< weak< StatModifier_Record > > );
	public import function GetPricePerPointCount() : Int32;
	public import function GetPricePerPointItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetPricePerPointItemHandle( index : Int32 ) : StatModifier_Record;
	public import function PricePerPointContains( item : weak< StatModifier_Record > ) : Bool;
}

importonly class VendorItem_Record extends VendorWare_Record
{
	public import function Item() : weak< Item_Record >;
	public import function ItemHandle() : Item_Record;
}

importonly class VendorItemQuery_Record extends VendorWare_Record
{
	public import function Query() : weak< ItemArrayQuery_Record >;
	public import function QueryHandle() : ItemArrayQuery_Record;
	public import function UniquesOnly() : Bool;
}

importonly class VendorProgressionBasedStock_Record extends TweakDBRecord
{
	public import function Items( out outList : array< weak< VendorItem_Record > > );
	public import function GetItemsCount() : Int32;
	public import function GetItemsItem( index : Int32 ) : weak< VendorItem_Record >;
	public import function GetItemsItemHandle( index : Int32 ) : VendorItem_Record;
	public import function ItemsContains( item : weak< VendorItem_Record > ) : Bool;
}

importonly class VendorType_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataVendorType;
}

importonly class VendorWare_Record extends TweakDBRecord
{
	public import function AvailabilityPrereq() : weak< IPrereq_Record >;
	public import function AvailabilityPrereqHandle() : IPrereq_Record;
	public import function GenerationPrereqs( out outList : array< weak< IPrereq_Record > > );
	public import function GetGenerationPrereqsCount() : Int32;
	public import function GetGenerationPrereqsItem( index : Int32 ) : weak< IPrereq_Record >;
	public import function GetGenerationPrereqsItemHandle( index : Int32 ) : IPrereq_Record;
	public import function GenerationPrereqsContains( item : weak< IPrereq_Record > ) : Bool;
	public import function Quantity( out outList : array< weak< StatModifier_Record > > );
	public import function GetQuantityCount() : Int32;
	public import function GetQuantityItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetQuantityItemHandle( index : Int32 ) : StatModifier_Record;
	public import function QuantityContains( item : weak< StatModifier_Record > ) : Bool;
	public import function ForceQuality() : CName;
}

importonly class VirtualNetwork_Record extends TweakDBRecord
{
	public import function Paths( out outList : array< weak< VirtualNetworkPath_Record > > );
	public import function GetPathsCount() : Int32;
	public import function GetPathsItem( index : Int32 ) : weak< VirtualNetworkPath_Record >;
	public import function GetPathsItemHandle( index : Int32 ) : VirtualNetworkPath_Record;
	public import function PathsContains( item : weak< VirtualNetworkPath_Record > ) : Bool;
	public import function SegmentMarker() : Vector3;
	public import function Scale() : Float;
	public import function OffsetMultiplier() : Float;
	public import function MinDistanceToOther() : Float;
}

importonly class VirtualNetworkPath_Record extends TweakDBRecord
{
	public import function Points() : array< Vector3 >;
	public import function GetPointsCount() : Int32;
	public import function GetPointsItem( index : Int32 ) : Vector3;
	public import function PointsContains( item : Vector3 ) : Bool;
}

importonly class VisionGroup_Record extends TweakDBRecord
{
	public import function GroupName() : CName;
	public import function Range() : Float;
}

importonly class VisionModuleBase_Record extends TweakDBRecord
{
	public import function Group() : weak< VisionGroup_Record >;
	public import function GroupHandle() : VisionGroup_Record;
	public import function Focus_cue() : CName;
	public import function Light_deact_mode() : CName;
	public import function Light_act_type() : CName;
	public import function Light_deact_type() : CName;
	public import function Default_cue() : CName;
	public import function Heavy_act_type() : CName;
	public import function Light_act_mode() : CName;
	public import function Heavy_act_mode() : CName;
	public import function Heavy_deact_mode() : CName;
	public import function Heavy_deact_type() : CName;
	public import function Prereq() : CName;
	public import function ObjectPrereq() : CName;
	public import function Light_act_delay() : Float;
	public import function Light_deact_duration() : Float;
	public import function Heavy_deact_duration() : Float;
	public import function Light_act_duration() : Float;
	public import function Heavy_act_delay() : Float;
	public import function Light_deact_delay() : Float;
	public import function Default_color() : Int32;
	public import function Focus_color() : Int32;
	public import function Heavy_act_duration() : Float;
	public import function Heavy_deact_delay() : Float;
	public import function Default_seeThroughWalls() : Bool;
	public import function Focus_seeThroughWalls() : Bool;
}

importonly class VisualTagsPrereq_Record extends IPrereq_Record
{
	public import function AllowedTags() : array< CName >;
	public import function GetAllowedTagsCount() : Int32;
	public import function GetAllowedTagsItem( index : Int32 ) : CName;
	public import function AllowedTagsContains( item : CName ) : Bool;
	public import function Invert() : Bool;
}

importonly class Weakspot_Record extends SpawnableObject_Record
{
	public import function SlotToAttach() : weak< AttachmentSlot_Record >;
	public import function SlotToAttachHandle() : AttachmentSlot_Record;
	public import function OnDestroyedEffectors( out outList : array< weak< Effector_Record > > );
	public import function GetOnDestroyedEffectorsCount() : Int32;
	public import function GetOnDestroyedEffectorsItem( index : Int32 ) : weak< Effector_Record >;
	public import function GetOnDestroyedEffectorsItemHandle( index : Int32 ) : Effector_Record;
	public import function OnDestroyedEffectorsContains( item : weak< Effector_Record > ) : Bool;
	public import function ValidCharacterAppearances() : array< CName >;
	public import function GetValidCharacterAppearancesCount() : Int32;
	public import function GetValidCharacterAppearancesItem( index : Int32 ) : CName;
	public import function ValidCharacterAppearancesContains( item : CName ) : Bool;
	public import function GameplayTags() : array< CName >;
	public import function GetGameplayTagsCount() : Int32;
	public import function GetGameplayTagsItem( index : Int32 ) : CName;
	public import function GameplayTagsContains( item : CName ) : Bool;
}

importonly class WeaponEvolution_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Type() : gamedataWeaponEvolution;
}

importonly class WeaponFxPackage_Record extends TweakDBRecord
{
	public import function Vfx_impact_tire_car_tpp() : weak< MaterialFx_Record >;
	public import function Vfx_impact_tire_car_tppHandle() : MaterialFx_Record;
	public import function Vfx_impact_food() : weak< MaterialFx_Record >;
	public import function Vfx_impact_foodHandle() : MaterialFx_Record;
	public import function Vfx_impact_linoleum() : weak< MaterialFx_Record >;
	public import function Vfx_impact_linoleumHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_ricochet() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_ricochetHandle() : MaterialFx_Record;
	public import function Vfx_impact_rubber() : weak< MaterialFx_Record >;
	public import function Vfx_impact_rubberHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_car_pipe_steam() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_car_pipe_steamHandle() : MaterialFx_Record;
	public import function Vfx_impact_tiles() : weak< MaterialFx_Record >;
	public import function Vfx_impact_tilesHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_car_tpp() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_car_tppHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_car_ricochet_tpp() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_car_ricochet_tppHandle() : MaterialFx_Record;
	public import function Vfx_impact_glass_semitransparent() : weak< MaterialFx_Record >;
	public import function Vfx_impact_glass_semitransparentHandle() : MaterialFx_Record;
	public import function Vfx_impact_dirt() : weak< MaterialFx_Record >;
	public import function Vfx_impact_dirtHandle() : MaterialFx_Record;
	public import function Vfx_impact_stone() : weak< MaterialFx_Record >;
	public import function Vfx_impact_stoneHandle() : MaterialFx_Record;
	public import function Vfx_impact_plastic_car_tpp() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plastic_car_tppHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_pipe_water() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_pipe_waterHandle() : MaterialFx_Record;
	public import function Vfx_impact_default() : weak< MaterialFx_Record >;
	public import function Vfx_impact_defaultHandle() : MaterialFx_Record;
	public import function Npc_vfx_set() : weak< WeaponVFXSet_Record >;
	public import function Npc_vfx_setHandle() : WeaponVFXSet_Record;
	public import function Vfx_impact_metal_car() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_carHandle() : MaterialFx_Record;
	public import function Vfx_impact_plastic_car_electronics_tpp() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plastic_car_electronics_tppHandle() : MaterialFx_Record;
	public import function Vfx_impact_water() : weak< MaterialFx_Record >;
	public import function Vfx_impact_waterHandle() : MaterialFx_Record;
	public import function Vfx_impact_plexiglass() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plexiglassHandle() : MaterialFx_Record;
	public import function Vfx_impact_upholstery_car_tpp() : weak< MaterialFx_Record >;
	public import function Vfx_impact_upholstery_car_tppHandle() : MaterialFx_Record;
	public import function Vfx_impact_character_flesh() : weak< MaterialFx_Record >;
	public import function Vfx_impact_character_fleshHandle() : MaterialFx_Record;
	public import function Vfx_impact_wood_tree() : weak< MaterialFx_Record >;
	public import function Vfx_impact_wood_treeHandle() : MaterialFx_Record;
	public import function Vfx_impact_plastic() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plasticHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_car_ricochet() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_car_ricochetHandle() : MaterialFx_Record;
	public import function Vfx_impact_cardboard() : weak< MaterialFx_Record >;
	public import function Vfx_impact_cardboardHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_painted() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_paintedHandle() : MaterialFx_Record;
	public import function Vfx_impact_glass_car_tpp() : weak< MaterialFx_Record >;
	public import function Vfx_impact_glass_car_tppHandle() : MaterialFx_Record;
	public import function Vfx_impact_leaves() : weak< MaterialFx_Record >;
	public import function Vfx_impact_leavesHandle() : MaterialFx_Record;
	public import function Vfx_impact_furniture_leather() : weak< MaterialFx_Record >;
	public import function Vfx_impact_furniture_leatherHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_car_electronics() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_car_electronicsHandle() : MaterialFx_Record;
	public import function Vfx_impact_meat() : weak< MaterialFx_Record >;
	public import function Vfx_impact_meatHandle() : MaterialFx_Record;
	public import function Vfx_impact_carpet() : weak< MaterialFx_Record >;
	public import function Vfx_impact_carpetHandle() : MaterialFx_Record;
	public import function Vfx_impact_furniture_upholstery() : weak< MaterialFx_Record >;
	public import function Vfx_impact_furniture_upholsteryHandle() : MaterialFx_Record;
	public import function Vfx_impact_concrete() : weak< MaterialFx_Record >;
	public import function Vfx_impact_concreteHandle() : MaterialFx_Record;
	public import function Vfx_impact_upholstery_car() : weak< MaterialFx_Record >;
	public import function Vfx_impact_upholstery_carHandle() : MaterialFx_Record;
	public import function Vfx_impact_asphalt() : weak< MaterialFx_Record >;
	public import function Vfx_impact_asphaltHandle() : MaterialFx_Record;
	public import function Vfx_impact_plastic_car() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plastic_carHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_car_electronics_tpp() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_car_electronics_tppHandle() : MaterialFx_Record;
	public import function Vfx_impact_plastic_road() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plastic_roadHandle() : MaterialFx_Record;
	public import function Vfx_impact_ceramic() : weak< MaterialFx_Record >;
	public import function Vfx_impact_ceramicHandle() : MaterialFx_Record;
	public import function Vfx_impact_plastic_car_electronics() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plastic_car_electronicsHandle() : MaterialFx_Record;
	public import function Vfx_impact_paper() : weak< MaterialFx_Record >;
	public import function Vfx_impact_paperHandle() : MaterialFx_Record;
	public import function Vfx_impact_plaster() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plasterHandle() : MaterialFx_Record;
	public import function Vfx_impact_glass_car() : weak< MaterialFx_Record >;
	public import function Vfx_impact_glass_carHandle() : MaterialFx_Record;
	public import function Player_vfx_set() : weak< WeaponVFXSet_Record >;
	public import function Player_vfx_setHandle() : WeaponVFXSet_Record;
	public import function Vfx_impact_character_metal() : weak< MaterialFx_Record >;
	public import function Vfx_impact_character_metalHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_pipe_steam() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_pipe_steamHandle() : MaterialFx_Record;
	public import function Vfx_impact_cyberware_metal_head() : weak< MaterialFx_Record >;
	public import function Vfx_impact_cyberware_metal_headHandle() : MaterialFx_Record;
	public import function Vfx_impact_wood() : weak< MaterialFx_Record >;
	public import function Vfx_impact_woodHandle() : MaterialFx_Record;
	public import function Vfx_impact_sand() : weak< MaterialFx_Record >;
	public import function Vfx_impact_sandHandle() : MaterialFx_Record;
	public import function Vfx_impact_cyberware_metal() : weak< MaterialFx_Record >;
	public import function Vfx_impact_cyberware_metalHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_catwalk() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_catwalkHandle() : MaterialFx_Record;
	public import function Vfx_impact_glass() : weak< MaterialFx_Record >;
	public import function Vfx_impact_glassHandle() : MaterialFx_Record;
	public import function Vfx_impact_character_flesh_head() : weak< MaterialFx_Record >;
	public import function Vfx_impact_character_flesh_headHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_hollow() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_hollowHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metalHandle() : MaterialFx_Record;
	public import function Vfx_impact_tire_car() : weak< MaterialFx_Record >;
	public import function Vfx_impact_tire_carHandle() : MaterialFx_Record;
	public import function Vfx_impact_camouflage() : weak< MaterialFx_Record >;
	public import function Vfx_impact_camouflageHandle() : MaterialFx_Record;
	public import function Vfx_impact_leather() : weak< MaterialFx_Record >;
	public import function Vfx_impact_leatherHandle() : MaterialFx_Record;
	public import function Vfx_impact_meatbag() : weak< MaterialFx_Record >;
	public import function Vfx_impact_meatbagHandle() : MaterialFx_Record;
	public import function Vfx_impact_fabrics() : weak< MaterialFx_Record >;
	public import function Vfx_impact_fabricsHandle() : MaterialFx_Record;
	public import function Vfx_impact_character_armor() : weak< MaterialFx_Record >;
	public import function Vfx_impact_character_armorHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_techpiercable() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_techpiercableHandle() : MaterialFx_Record;
	public import function Vfx_impact_grass() : weak< MaterialFx_Record >;
	public import function Vfx_impact_grassHandle() : MaterialFx_Record;
	public import function Vfx_impact_cyberware_flesh() : weak< MaterialFx_Record >;
	public import function Vfx_impact_cyberware_fleshHandle() : MaterialFx_Record;
	public import function Vfx_impact_trash_bag() : weak< MaterialFx_Record >;
	public import function Vfx_impact_trash_bagHandle() : MaterialFx_Record;
	public import function Vfx_impact_flesh() : weak< MaterialFx_Record >;
	public import function Vfx_impact_fleshHandle() : MaterialFx_Record;
	public import function Vfx_impact_carpet_techpiercable() : weak< MaterialFx_Record >;
	public import function Vfx_impact_carpet_techpiercableHandle() : MaterialFx_Record;
	public import function Vfx_impact_brick() : weak< MaterialFx_Record >;
	public import function Vfx_impact_brickHandle() : MaterialFx_Record;
	public import function Vfx_impact_glass_electronics() : weak< MaterialFx_Record >;
	public import function Vfx_impact_glass_electronicsHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_road() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_roadHandle() : MaterialFx_Record;
	public import function Vfx_impact_plastic_electronics() : weak< MaterialFx_Record >;
	public import function Vfx_impact_plastic_electronicsHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_heavypiercable() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_heavypiercableHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_car_pipe_water() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_car_pipe_waterHandle() : MaterialFx_Record;
	public import function Vfx_impact_trash() : weak< MaterialFx_Record >;
	public import function Vfx_impact_trashHandle() : MaterialFx_Record;
	public import function Vfx_impact_character_vr() : weak< MaterialFx_Record >;
	public import function Vfx_impact_character_vrHandle() : MaterialFx_Record;
	public import function Vfx_impact_character_cyberflesh() : weak< MaterialFx_Record >;
	public import function Vfx_impact_character_cyberfleshHandle() : MaterialFx_Record;
	public import function Vfx_impact_neon() : weak< MaterialFx_Record >;
	public import function Vfx_impact_neonHandle() : MaterialFx_Record;
	public import function Vfx_impact_glass_bulletproof() : weak< MaterialFx_Record >;
	public import function Vfx_impact_glass_bulletproofHandle() : MaterialFx_Record;
	public import function Vfx_impact_glass_opaque() : weak< MaterialFx_Record >;
	public import function Vfx_impact_glass_opaqueHandle() : MaterialFx_Record;
	public import function Vfx_impact_glass_dst() : weak< MaterialFx_Record >;
	public import function Vfx_impact_glass_dstHandle() : MaterialFx_Record;
	public import function Vfx_impact_leaves_semitransparent() : weak< MaterialFx_Record >;
	public import function Vfx_impact_leaves_semitransparentHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_semitransparent() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_semitransparentHandle() : MaterialFx_Record;
	public import function Vfx_impact_metal_transparent() : weak< MaterialFx_Record >;
	public import function Vfx_impact_metal_transparentHandle() : MaterialFx_Record;
	public import function Vfx_impact_vehicle_chassis() : weak< MaterialFx_Record >;
	public import function Vfx_impact_vehicle_chassisHandle() : MaterialFx_Record;
	public import function Vfx_impact_wood_bamboo_poles() : weak< MaterialFx_Record >;
	public import function Vfx_impact_wood_bamboo_polesHandle() : MaterialFx_Record;
	public import function Vfx_impact_wood_crown() : weak< MaterialFx_Record >;
	public import function Vfx_impact_wood_crownHandle() : MaterialFx_Record;
	public import function Vfx_impact_wood_hedge() : weak< MaterialFx_Record >;
	public import function Vfx_impact_wood_hedgeHandle() : MaterialFx_Record;
	public import function Vfx_impact_mud() : weak< MaterialFx_Record >;
	public import function Vfx_impact_mudHandle() : MaterialFx_Record;
	public import function Vfx_impact_concrete_water_puddles() : weak< MaterialFx_Record >;
	public import function Vfx_impact_concrete_water_puddlesHandle() : MaterialFx_Record;
	public import function Vfx_impact_add_names() : array< CName >;
	public import function GetVfx_impact_add_namesCount() : Int32;
	public import function GetVfx_impact_add_namesItem( index : Int32 ) : CName;
	public import function Vfx_impact_add_namesContains( item : CName ) : Bool;
	public import function Character_surrounding_decals() : array< ResRef >;
	public import function GetCharacter_surrounding_decalsCount() : Int32;
	public import function GetCharacter_surrounding_decalsItem( index : Int32 ) : ResRef;
	public import function Character_pseudo_piercing() : array< ResRef >;
	public import function GetCharacter_pseudo_piercingCount() : Int32;
	public import function GetCharacter_pseudo_piercingItem( index : Int32 ) : ResRef;
	public import function Vfx_impact_metal_techpiercable_material() : CName;
	public import function Vfx_impact_leaves_material() : CName;
	public import function Vfx_impact_plaster_material() : CName;
	public import function Vfx_impact_tiles_material() : CName;
	public import function Vfx_impact_food_material() : CName;
	public import function Vfx_impact_metal_car_ricochet_material() : CName;
	public import function Vfx_impact_meat_material() : CName;
	public import function Vfx_impact_brick_material() : CName;
	public import function Vfx_impact_glass_material() : CName;
	public import function Vfx_impact_camouflage_material() : CName;
	public import function Vfx_impact_paper_material() : CName;
	public import function Vfx_impact_water_material() : CName;
	public import function Vfx_impact_metal_car_electronics_material() : CName;
	public import function Vfx_impact_dirt_material() : CName;
	public import function Vfx_impact_furniture_leather_material() : CName;
	public import function Vfx_impact_metal_heavypiercable_material() : CName;
	public import function Vfx_impact_ceramic_material() : CName;
	public import function Vfx_impact_character_armor_material() : CName;
	public import function Vfx_impact_character_metal_material() : CName;
	public import function Vfx_impact_asphalt_material() : CName;
	public import function Vfx_impact_metal_material() : CName;
	public import function Vfx_impact_upholstery_car_material() : CName;
	public import function Vfx_impact_flesh_material() : CName;
	public import function Vfx_impact_fabrics_material() : CName;
	public import function Vfx_impact_carpet_material() : CName;
	public import function Vfx_impact_carpet_techpiercable_material() : CName;
	public import function Vfx_impact_glass_electronics_material() : CName;
	public import function Vfx_impact_sand_material() : CName;
	public import function Vfx_impact_metal_car_pipe_water_material() : CName;
	public import function Vfx_impact_character_flesh_head_material() : CName;
	public import function Vfx_impact_plastic_road_material() : CName;
	public import function Vfx_impact_character_flesh_material() : CName;
	public import function Vfx_impact_cardboard_material() : CName;
	public import function Vfx_impact_glass_car_material() : CName;
	public import function Vfx_impact_plastic_car_electronics_material() : CName;
	public import function Vfx_impact_metal_pipe_steam_material() : CName;
	public import function Vfx_impact_plastic_car_material() : CName;
	public import function Vfx_impact_concrete_material() : CName;
	public import function Vfx_impact_metal_hollow_material() : CName;
	public import function Vfx_impact_cyberware_flesh_material() : CName;
	public import function Vfx_impact_cyberware_metal_head_material() : CName;
	public import function Vfx_impact_metal_catwalk_material() : CName;
	public import function Vfx_impact_trash_material() : CName;
	public import function Vfx_impact_trash_bag_material() : CName;
	public import function Vfx_impact_leather_material() : CName;
	public import function Vfx_impact_plastic_electronics_material() : CName;
	public import function Vfx_impact_tire_car_material() : CName;
	public import function Vfx_impact_metal_road_material() : CName;
	public import function Vfx_impact_metal_ricochet_material() : CName;
	public import function Vfx_impact_grass_material() : CName;
	public import function Vfx_impact_metal_pipe_water_material() : CName;
	public import function Vfx_impact_metal_car_material() : CName;
	public import function Vfx_impact_wood_tree_material() : CName;
	public import function Vfx_impact_furniture_upholstery_material() : CName;
	public import function Vfx_impact_meatbag_material() : CName;
	public import function Vfx_impact_metal_painted_material() : CName;
	public import function Vfx_impact_plexiglass_material() : CName;
	public import function Vfx_impact_stone_material() : CName;
	public import function Vfx_impact_plastic_material() : CName;
	public import function Vfx_impact_glass_semitransparent_material() : CName;
	public import function Vfx_impact_rubber_material() : CName;
	public import function Vfx_impact_cyberware_metal_material() : CName;
	public import function Vfx_impact_linoleum_material() : CName;
	public import function Vfx_impact_wood_material() : CName;
	public import function Vfx_impact_metal_car_pipe_steam_material() : CName;
	public import function Vfx_impact_character_vr_material() : CName;
	public import function Vfx_impact_character_cyberflesh_material() : CName;
	public import function Vfx_impact_neon_material() : CName;
	public import function Vfx_impact_glass_bulletproof_material() : CName;
	public import function Vfx_impact_glass_opaque_material() : CName;
	public import function Vfx_impact_glass_dst_material() : CName;
	public import function Vfx_impact_leaves_semitransparent_material() : CName;
	public import function Vfx_impact_metal_semitransparent_material() : CName;
	public import function Vfx_impact_metal_transparent_material() : CName;
	public import function Vfx_impact_vehicle_chassis_material() : CName;
	public import function Vfx_impact_wood_bamboo_poles_material() : CName;
	public import function Vfx_impact_wood_crown_material() : CName;
	public import function Vfx_impact_wood_hedge_material() : CName;
	public import function Vfx_impact_mud_material() : CName;
	public import function Vfx_impact_concrete_water_puddles_material() : CName;
	public import function Vfx_hitscan_trail() : ResRef;
	public import function Vfx_hitscan_trail_thermal() : ResRef;
	public import function Vfx_hitscan_trail_electric() : ResRef;
	public import function Vfx_hitscan_trail_chemical() : ResRef;
	public import function Vfx_hitscan_trail_slowmo() : ResRef;
	public import function Vfx_hitscan_trail_ricochet() : ResRef;
	public import function Vfx_projectile_trail_name() : CName;
	public import function NPC_vfx_hitscan_trail() : ResRef;
	public import function NPC_vfx_hitscan_trail_thermal() : ResRef;
	public import function NPC_vfx_hitscan_trail_electric() : ResRef;
	public import function NPC_vfx_hitscan_trail_chemical() : ResRef;
	public import function Vfx_impact_damage_thermal() : ResRef;
	public import function Vfx_impact_damage_electric() : ResRef;
	public import function Vfx_impact_damage_chemical() : ResRef;
	public import function Vfx_impact_add() : ResRef;
	public import function Vfx_impact_add_names_material() : CName;
	public import function Vfx_ricochet() : ResRef;
	public import function Sfx_impact_context() : CName;
	public import function Vfx_ground_throw() : ResRef;
	public import function Vfx_extra_hit() : ResRef;
	public import function WaterImpulseRadius() : Float;
	public import function WaterImpulseStrength() : Float;
	public import function WaterImpulseFrames() : Int32;
	public import function Vfx_impact_add_enable() : Bool;
	public import function PreloadWaterEffects() : Bool;
}

importonly class WeaponItem_Record extends Item_Record
{
	public import function Ammo() : weak< Item_Record >;
	public import function AmmoHandle() : Item_Record;
	public import function FxPackageQuickMelee() : weak< WeaponFxPackage_Record >;
	public import function FxPackageQuickMeleeHandle() : WeaponFxPackage_Record;
	public import function HudIcon() : weak< UIIcon_Record >;
	public import function HudIconHandle() : UIIcon_Record;
	public import function RangedAttacks() : weak< RangedAttackPackage_Record >;
	public import function RangedAttacksHandle() : RangedAttackPackage_Record;
	public import function SecondaryTriggerMode() : weak< TriggerMode_Record >;
	public import function SecondaryTriggerModeHandle() : TriggerMode_Record;
	public import function Evolution() : weak< WeaponEvolution_Record >;
	public import function EvolutionHandle() : WeaponEvolution_Record;
	public import function Manufacturer() : weak< WeaponManufacturer_Record >;
	public import function ManufacturerHandle() : WeaponManufacturer_Record;
	public import function PrimaryTriggerMode() : weak< TriggerMode_Record >;
	public import function PrimaryTriggerModeHandle() : TriggerMode_Record;
	public import function FxPackage() : weak< WeaponFxPackage_Record >;
	public import function FxPackageHandle() : WeaponFxPackage_Record;
	public import function DamageType() : weak< DamageType_Record >;
	public import function DamageTypeHandle() : DamageType_Record;
	public import function HolsteredItem() : weak< Item_Record >;
	public import function HolsteredItemHandle() : Item_Record;
	public import function Attacks( out outList : array< weak< Attack_Record > > );
	public import function GetAttacksCount() : Int32;
	public import function GetAttacksItem( index : Int32 ) : weak< Attack_Record >;
	public import function GetAttacksItemHandle( index : Int32 ) : Attack_Record;
	public import function AttacksContains( item : weak< Attack_Record > ) : Bool;
	public import function TriggerModes( out outList : array< weak< TriggerMode_Record > > );
	public import function GetTriggerModesCount() : Int32;
	public import function GetTriggerModesItem( index : Int32 ) : weak< TriggerMode_Record >;
	public import function GetTriggerModesItemHandle( index : Int32 ) : TriggerMode_Record;
	public import function TriggerModesContains( item : weak< TriggerMode_Record > ) : Bool;
	public import function ShootingPatternPackages( out outList : array< weak< AIPatternsPackage_Record > > );
	public import function GetShootingPatternPackagesCount() : Int32;
	public import function GetShootingPatternPackagesItem( index : Int32 ) : weak< AIPatternsPackage_Record >;
	public import function GetShootingPatternPackagesItemHandle( index : Int32 ) : AIPatternsPackage_Record;
	public import function ShootingPatternPackagesContains( item : weak< AIPatternsPackage_Record > ) : Bool;
	public import function AudioWeaponConfiguration() : CName;
	public import function TriggerEffectName() : CName;
	public import function GameplayDescription() : CName;
	public import function EffectiveRangeFalloffCurve() : CName;
	public import function NPCAnimWrapperWeightOverride() : CName;
	public import function PreviewEffectTag() : CName;
	public import function EffectiveRangeCurve() : CName;
	public import function ProjectileEaseOutCurveName() : CName;
	public import function PreviewEffectName() : CName;
	public import function IkOffset() : Vector3;
	public import function ForcedMinHitReaction() : Int32;
	public import function UninterruptibleEmptyReloadStart() : Float;
	public import function UninterruptibleReloadStart() : Float;
	public import function BaseEmptyReloadTime() : Float;
	public import function BaseReloadTime() : Float;
	public import function UseForcedTBHZOffset() : Bool;
	public import function IsIKEnabled() : Bool;
	public import function UseShootVFXOnlyOnFirstShot() : Bool;
}

importonly class WeaponManufacturer_Record extends TweakDBRecord
{
	public import function Name() : String;
	public import function Type() : gamedataWeaponManufacturer;
}

importonly class WeaponSafeModeBound_Record extends TweakDBRecord
{
	public import function PitchMin() : Float;
	public import function PitchMax() : Float;
	public import function YawMin() : Float;
	public import function YawMax() : Float;
}

importonly class WeaponSafeModeBounds_Record extends TweakDBRecord
{
	public import function WindshieldBound() : weak< WeaponSafeModeBound_Record >;
	public import function WindshieldBoundHandle() : WeaponSafeModeBound_Record;
	public import function BackBound() : weak< WeaponSafeModeBound_Record >;
	public import function BackBoundHandle() : WeaponSafeModeBound_Record;
	public import function EnableSafeModeBounds() : Bool;
}

importonly class WeaponVFXAction_Record extends TweakDBRecord
{
	public import function FxAction() : weak< FxAction_Record >;
	public import function FxActionHandle() : FxAction_Record;
	public import function FxActionType() : weak< FxActionType_Record >;
	public import function FxActionTypeHandle() : FxActionType_Record;
	public import function FxName() : CName;
}

importonly class WeaponVFXSet_Record extends TweakDBRecord
{
	public import function Actions( out outList : array< weak< WeaponVFXAction_Record > > );
	public import function GetActionsCount() : Int32;
	public import function GetActionsItem( index : Int32 ) : weak< WeaponVFXAction_Record >;
	public import function GetActionsItemHandle( index : Int32 ) : WeaponVFXAction_Record;
	public import function ActionsContains( item : weak< WeaponVFXAction_Record > ) : Bool;
}

importonly class WeaponsTooltipData_Record extends TweakDBRecord
{
	public import function StatsToCompare( out outList : array< weak< Stat_Record > > );
	public import function GetStatsToCompareCount() : Int32;
	public import function GetStatsToCompareItem( index : Int32 ) : weak< Stat_Record >;
	public import function GetStatsToCompareItemHandle( index : Int32 ) : Stat_Record;
	public import function StatsToCompareContains( item : weak< Stat_Record > ) : Bool;
	public import function MaxStatsValue() : array< Float >;
	public import function GetMaxStatsValueCount() : Int32;
	public import function GetMaxStatsValueItem( index : Int32 ) : Float;
	public import function MaxStatsValueContains( item : Float ) : Bool;
}

importonly class Weather_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
}

importonly class WeatherPreset_Record extends SpawnableObject_Record
{
	public import function Name() : CName;
}

importonly class Website_Record extends TweakDBRecord
{
	public import function Url() : String;
	public import function WidgetPath() : ResRef;
}

importonly class WeightedCharacter_Record extends TweakDBRecord
{
	public import function Character() : weak< Character_Record >;
	public import function CharacterHandle() : Character_Record;
	public import function Weight() : Float;
}

importonly class WidgetDefinition_Record extends TweakDBRecord
{
	public import function LibraryID() : String;
	public import function Styles( out outList : array< weak< WidgetStyle_Record > > );
	public import function GetStylesCount() : Int32;
	public import function GetStylesItem( index : Int32 ) : weak< WidgetStyle_Record >;
	public import function GetStylesItemHandle( index : Int32 ) : WidgetStyle_Record;
	public import function StylesContains( item : weak< WidgetStyle_Record > ) : Bool;
	public import function Ratios( out outList : array< weak< WidgetRatio_Record > > );
	public import function GetRatiosCount() : Int32;
	public import function GetRatiosItem( index : Int32 ) : weak< WidgetRatio_Record >;
	public import function GetRatiosItemHandle( index : Int32 ) : WidgetRatio_Record;
	public import function RatiosContains( item : weak< WidgetRatio_Record > ) : Bool;
	public import function LibraryPath() : ResRef;
	public import function UseContentRatio() : Bool;
}

importonly class WidgetRatio_Record extends TweakDBRecord
{
	public import function EnumName() : String;
}

importonly class WidgetStyle_Record extends TweakDBRecord
{
	public import function EnumName() : String;
	public import function Type() : gamedataWidgetStyle;
}

importonly class WorkspotActionType_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataWorkspotActionType;
}

importonly class WorkspotCategory_Record extends TweakDBRecord
{
	public import function Comment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataWorkspotCategory;
}

importonly class WorkspotReactionType_Record extends TweakDBRecord
{
	public import function EnumName() : CName;
	public import function Type() : gamedataWorkspotReactionType;
}

importonly class WorkspotStatusEffect_Record extends StatusEffect_Record
{
}

importonly class WorldMapFilter_Record extends TweakDBRecord
{
	public import function EnumComment() : String;
	public import function EnumName() : CName;
	public import function Type() : gamedataWorldMapFilter;
}

importonly class WorldMapFiltersList_Record extends TweakDBRecord
{
	public import function List( out outList : array< weak< MappinUIFilterGroup_Record > > );
	public import function GetListCount() : Int32;
	public import function GetListItem( index : Int32 ) : weak< MappinUIFilterGroup_Record >;
	public import function GetListItemHandle( index : Int32 ) : MappinUIFilterGroup_Record;
	public import function ListContains( item : weak< MappinUIFilterGroup_Record > ) : Bool;
}

importonly class WorldMapFreeCameraSettings_Record extends TweakDBRecord
{
	public import function RotationMin() : EulerAngles;
	public import function RotationMax() : EulerAngles;
	public import function RotationSpeed() : EulerAngles;
	public import function RotationDefault() : EulerAngles;
	public import function ZoomDefaultInFastTravel() : Float;
	public import function PanSpeedMax() : Float;
	public import function MouseRotateStrength() : Float;
	public import function MousePanStrength() : Float;
	public import function ZoomSpeedMin() : Float;
	public import function ZoomDefault() : Float;
	public import function ZoomMax() : Float;
	public import function FovMin() : Float;
	public import function ZoomSpeedMax() : Float;
	public import function ZoomMin() : Float;
	public import function MouseZoomSpeedMin() : Float;
	public import function FovMax() : Float;
	public import function MouseZoomSpeedMax() : Float;
	public import function PanSpeedMin() : Float;
	public import function IconScaleMin() : Float;
	public import function IconScaleMax() : Float;
	public import function ZoomSpeed() : Float;
	public import function PitchRelativeToZoom() : Bool;
}

importonly class WorldMapSettings_Record extends TweakDBRecord
{
	public import function FreeCamera() : weak< WorldMapFreeCameraSettings_Record >;
	public import function FreeCameraHandle() : WorldMapFreeCameraSettings_Record;
	public import function TopDownCamera() : weak< WorldMapFreeCameraSettings_Record >;
	public import function TopDownCameraHandle() : WorldMapFreeCameraSettings_Record;
	public import function ZoomLevels( out outList : array< weak< WorldMapZoomLevel_Record > > );
	public import function GetZoomLevelsCount() : Int32;
	public import function GetZoomLevelsItem( index : Int32 ) : weak< WorldMapZoomLevel_Record >;
	public import function GetZoomLevelsItemHandle( index : Int32 ) : WorldMapZoomLevel_Record;
	public import function ZoomLevelsContains( item : weak< WorldMapZoomLevel_Record > ) : Bool;
	public import function CursorBoundaryMin() : Vector2;
	public import function CursorBoundaryMax() : Vector2;
	public import function MouseZoomTransitionTime() : Float;
	public import function ZoomTransitionTime() : Float;
	public import function ZoomToZoomValue() : Float;
	public import function CameraModeTransitionTime() : Float;
	public import function ZoomToEnabledAtMinimumZoom() : Float;
	public import function NCPDEventsVisibilityRange() : Float;
	public import function EnableGroupTransitionAnimations() : Bool;
}

importonly class WorldMapZoomLevel_Record extends TweakDBRecord
{
	public import function MappinFilterGroups( out outList : array< weak< MappinUIFilterGroup_Record > > );
	public import function GetMappinFilterGroupsCount() : Int32;
	public import function GetMappinFilterGroupsItem( index : Int32 ) : weak< MappinUIFilterGroup_Record >;
	public import function GetMappinFilterGroupsItemHandle( index : Int32 ) : MappinUIFilterGroup_Record;
	public import function MappinFilterGroupsContains( item : weak< MappinUIFilterGroup_Record > ) : Bool;
	public import function Rotation() : EulerAngles;
	public import function Fov() : Float;
	public import function Zoom() : Float;
	public import function IconScale() : Float;
	public import function PanSpeed() : Float;
	public import function ShowDistricts() : Bool;
	public import function ShowSubDistricts() : Bool;
	public import function CanChangeFilters() : Bool;
}

importonly class XPPoints_Record extends TweakDBRecord
{
	public import function Type() : weak< Proficiency_Record >;
	public import function TypeHandle() : Proficiency_Record;
	public import function QuantityModifiers( out outList : array< weak< StatModifier_Record > > );
	public import function GetQuantityModifiersCount() : Int32;
	public import function GetQuantityModifiersItem( index : Int32 ) : weak< StatModifier_Record >;
	public import function GetQuantityModifiersItemHandle( index : Int32 ) : StatModifier_Record;
	public import function QuantityModifiersContains( item : weak< StatModifier_Record > ) : Bool;
}

importonly class XPPoints_inline0_Record extends ConstantStatModifier_Record
{
}

importonly class device_gameplay_role_Record extends ScannableData_Record
{
}

importonly class device_role_action_desctiption_Record extends ScannableData_Record
{
}

importonly class device_scanning_data_Record extends ScannableData_Record
{
}

importonly class npc_scanning_data_Record extends ScannableData_Record
{
}

