NoExportTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Reflection mirrors of C++ structs defined in Core or CoreUObject, those modules are not parsed by the Unreal Header Tool.
// The documentation comments here are only for use in the editor tooltips, and is ignored for the API docs.
// More complete documentation will be found in the files that have the full class definition, listed below.
 
#pragma once
 
// Help intellisense to avoid interpreting this file's declaration of FVector etc as it assumes !CPP by default
#ifndef CPP
#define CPP 1
#endif
 
#if CPP
 
// Include the real definitions of the noexport classes below to allow the generated cpp file to compile.
 
#include "PixelFormat.h"
 
#include "Misc/FallbackStruct.h"
#include "Misc/Guid.h"
#include "Misc/DateTime.h"
#include "Misc/Timespan.h"
#include "Misc/FrameRate.h"
#include "Misc/FrameTime.h"
#include "Misc/QualifiedFrameTime.h"
#include "Misc/FrameNumber.h"
#include "Misc/Timecode.h"
 
#include "UObject/TopLevelAssetPath.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/PropertyAccessUtil.h"
#include "Serialization/TestUndeclaredScriptStructObjectReferences.h"
 
#include "Math/InterpCurvePoint.h"
#include "Math/UnitConversion.h"
#include "Math/Vector.h"
#include "Math/Vector4.h"
#include "Math/Vector2D.h"
#include "Math/TwoVectors.h"
#include "Math/Plane.h"
#include "Math/Rotator.h"
#include "Math/Quat.h"
#include "Math/IntPoint.h"
#include "Math/IntVector.h"
#include "Math/Color.h"
#include "Math/Box.h"
#include "Math/Box2D.h"
#include "Math/BoxSphereBounds.h"
#include "Math/OrientedBox.h"
#include "Math/Matrix.h"
#include "Math/ScalarRegister.h"
#include "Math/RandomStream.h"
#include "Math/RangeBound.h"
#include "Math/Interval.h"
#include "Math/Sphere.h"
 
#include "Internationalization/PolyglotTextData.h"
 
#include "AssetRegistry/ARFilter.h"
#include "AssetRegistry/AssetBundleData.h"
#include "AssetRegistry/AssetData.h"
 
#endif
 
#if !CPP      //noexport class
 
 
UENUM()
namespace ESearchCase
{
    enum Type : int
    {
        CaseSensitive,
        IgnoreCase,
    };
}
 
UENUM()
namespace ESearchDir
{
    enum Type : int
    {
        FromStart,
        FromEnd,
    };
}
 
UENUM()
namespace ELogTimes
{
    enum Type : int
    {
        None UMETA(DisplayName = "None"),
 
        UTC UMETA(DisplayName = "UTC"),
 
        SinceGStartTime UMETA(DisplayName = "Time since application start"),
 
        Local UMETA(DisplayName = "Local time"),
    };
}
 
UENUM(BlueprintType, meta=(ScriptName="AxisType"))
namespace EAxis
{
    enum Type : int
    {
        None,
        X,
        Y,
        Z
    };
}
 
UENUM()
namespace EAxisList
{
    enum Type : int
    {
        None = 0,
        X = 1 << 0,
        Y = 1 << 1,
        Z = 1 << 2,
 
        Screen = 1 << 3,
        XY = X | Y,
        XZ = X | Z,
        YZ = Y | Z,
        XYZ = X | Y | Z,
        All = XYZ | Screen,
 
        ZRotation = YZ,
 
        Rotate2D = Screen,
 
        Left = 1 << 4,
        Up = 1 << 5,
        Forward = 1 << 6,
 
        LU = Left | Up,
        LF = Left | Forward,
        UF = Up | Forward,
        LeftUpForward = Left | Up | Forward,
    };
}
 
UENUM()
enum EInterpCurveMode : int
{
    CIM_Linear UMETA(DisplayName="Linear"),
    
    CIM_CurveAuto UMETA(DisplayName="Curve Auto"),
    
    CIM_Constant UMETA(DisplayName="Constant"),
    
    CIM_CurveUser UMETA(DisplayName="Curve User"),
    
    CIM_CurveBreak UMETA(DisplayName="Curve Break"),
    
    CIM_CurveAutoClamped UMETA(DisplayName="Curve Auto Clamped"),
};
 
UENUM()
enum EPixelFormat : int
{
    PF_Unknown,
    PF_A32B32G32R32F,
    PF_B8G8R8A8,
    PF_G8,
    PF_G16,
    PF_DXT1,
    PF_DXT3,
    PF_DXT5,
    PF_UYVY,
    PF_FloatRGB,
    PF_FloatRGBA,
    PF_DepthStencil,
    PF_ShadowDepth,
    PF_R32_FLOAT,
    PF_G16R16,
    PF_G16R16F,
    PF_G16R16F_FILTER,
    PF_G32R32F,
    PF_A2B10G10R10,
    PF_A16B16G16R16,
    PF_D24,
    PF_R16F,
    PF_R16F_FILTER,
    PF_BC5,
    PF_V8U8,
    PF_A1,
    PF_FloatR11G11B10,
    PF_A8,
    PF_R32_UINT,
    PF_R32_SINT,
    PF_PVRTC2,
    PF_PVRTC4,
    PF_R16_UINT,
    PF_R16_SINT,
    PF_R16G16B16A16_UINT,
    PF_R16G16B16A16_SINT,
    PF_R5G6B5_UNORM,
    PF_R8G8B8A8,
    PF_A8R8G8B8,
    PF_BC4,
    PF_R8G8,
    PF_ATC_RGB,
    PF_ATC_RGBA_E,
    PF_ATC_RGBA_I,
    PF_X24_G8,
    PF_ETC1,
    PF_ETC2_RGB,
    PF_ETC2_RGBA,
    PF_R32G32B32A32_UINT,
    PF_R16G16_UINT,
    PF_ASTC_4x4,
    PF_ASTC_6x6,
    PF_ASTC_8x8,
    PF_ASTC_10x10,
    PF_ASTC_12x12,
    PF_BC6H,
    PF_BC7,
    PF_R8_UINT,
    PF_L8,
    PF_XGXR8,
    PF_R8G8B8A8_UINT,
    PF_R8G8B8A8_SNORM,
    PF_R16G16B16A16_UNORM,
    PF_R16G16B16A16_SNORM,
    PF_PLATFORM_HDR_0,
    PF_PLATFORM_HDR_1,
    PF_PLATFORM_HDR_2,
    PF_NV12,
    PF_R32G32_UINT,
    PF_ETC2_R11_EAC,
    PF_ETC2_RG11_EAC,
    PF_R8,
    PF_B5G5R5A1_UNORM,
    PF_ASTC_4x4_HDR,    
    PF_ASTC_6x6_HDR,    
    PF_ASTC_8x8_HDR,    
    PF_ASTC_10x10_HDR,  
    PF_ASTC_12x12_HDR,
    PF_G16R16_SNORM,
    PF_R8G8_UINT,
    PF_R32G32B32_UINT,
    PF_R32G32B32_SINT,
    PF_R32G32B32F,
    PF_R8_SINT,
    PF_R64_UINT,
    PF_R9G9B9EXP5,
    PF_P010,
    PF_ASTC_4x4_NORM_RG,
    PF_ASTC_6x6_NORM_RG,
    PF_ASTC_8x8_NORM_RG,
    PF_ASTC_10x10_NORM_RG,
    PF_ASTC_12x12_NORM_RG,
    PF_R16G16_SINT,
    PF_MAX,
};
 
UENUM()
namespace EMouseCursor
{
    enum Type : int
    {
        None,
 
        Default,
 
        TextEditBeam,
 
        ResizeLeftRight,
 
        ResizeUpDown,
 
        ResizeSouthEast,
 
        ResizeSouthWest,
 
        CardinalCross,
 
        Crosshairs,
 
        Hand,
 
        GrabHand,
 
        GrabHandClosed,
 
        SlashedCircle,
 
        EyeDropper,
 
        Custom,
    };
}
 
UENUM(BlueprintType)
enum class EUnit : uint8
{
    Micrometers, Millimeters, Centimeters, Meters, Kilometers,
    Inches, Feet, Yards, Miles,
    Lightyears,
 
    Degrees, Radians,
 
    CentimetersPerSecond, MetersPerSecond, KilometersPerHour, MilesPerHour,
 
    DegreesPerSecond, RadiansPerSecond,
 
    CentimetersPerSecondSquared, MetersPerSecondSquared,
 
    Celsius, Farenheit, Kelvin,
 
    Micrograms, Milligrams, Grams, Kilograms, MetricTons,
    Ounces, Pounds, Stones,
 
    GramsPerCubicCentimeter, GramsPerCubicMeter, KilogramsPerCubicCentimeter, KilogramsPerCubicMeter,
 
    Newtons, PoundsForce, KilogramsForce, KilogramCentimetersPerSecondSquared,
 
    NewtonMeters, KilogramCentimetersSquaredPerSecondSquared,
 
    NewtonSeconds, KilogramCentimeters, KilogramMeters,
 
    Hertz, Kilohertz, Megahertz, Gigahertz, RevolutionsPerMinute,
 
    Bytes, Kilobytes, Megabytes, Gigabytes, Terabytes,
 
    Lumens,
    
    Candela,
    
    Lux,
    
    CandelaPerMeter2,
    
    ExposureValue,
 
    Nanoseconds, Microseconds, Milliseconds, Seconds, Minutes, Hours, Days, Months, Years,
 
    PixelsPerInch,
 
    Percentage,
 
    Multiplier,
 
    Pascals, KiloPascals, MegaPascals, GigaPascals,
 
    Unspecified
};
 
UENUM(BlueprintType)
enum class EAppMsgCategory : uint8
{
    Warning,
    Error,
    Success,
    Info,
};
 
UENUM(BlueprintType)
namespace EAppReturnType
{
    enum Type : int
    {
        No,
        Yes,
        YesAll,
        NoAll,
        Cancel,
        Ok,
        Retry,
        Continue,
    };
}
 
UENUM(BlueprintType)
namespace EAppMsgType
{
    enum Type : int
    {
        Ok,
        YesNo,
        OkCancel,
        YesNoCancel,
        CancelRetryContinue,
        YesNoYesAllNoAll,
        YesNoYesAllNoAllCancel,
        YesNoYesAll,
    };
}
 
USTRUCT(noexport, IsAlwaysAccessible, HasDefaults)
struct FFallbackStruct
{
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults)
struct FGuid
{
    UPROPERTY(EditAnywhere, SaveGame, Category=Guid)
    int32 A;
 
    UPROPERTY(EditAnywhere, SaveGame, Category=Guid)
    int32 B;
 
    UPROPERTY(EditAnywhere, SaveGame, Category=Guid)
    int32 C;
 
    UPROPERTY(EditAnywhere, SaveGame, Category=Guid)
    int32 D;
};
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta = (ScriptDefaultMake, ScriptDefaultBreak, HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeVector", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakVector"))
struct FVector3f
{
    UPROPERTY(EditAnywhere, Category = Vector, SaveGame)
    float X;
 
    UPROPERTY(EditAnywhere, Category = Vector, SaveGame)
    float Y;
 
    UPROPERTY(EditAnywhere, Category = Vector, SaveGame)
    float Z;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FVector3d
{
    UPROPERTY(EditAnywhere, Category = Vector, SaveGame)
    double X;
 
    UPROPERTY(EditAnywhere, Category = Vector, SaveGame)
    double Y;
 
    UPROPERTY(EditAnywhere, Category = Vector, SaveGame)
    double Z;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta = (HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeVector", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakVector"))
struct FVector
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Vector, SaveGame)
    FLargeWorldCoordinatesReal X;       //~ Alias for float/double depending on LWC status. Note: Will be refactored to double before UE5 ships.
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Vector, SaveGame)
    FLargeWorldCoordinatesReal Y;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Vector, SaveGame)
    FLargeWorldCoordinatesReal Z;
};
 
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta = (ScriptDefaultMake, ScriptDefaultBreak, HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeVector4", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakVector4"))
struct FVector4f
{
    UPROPERTY(EditAnywhere, Category = Vector4, SaveGame)
    float X;
 
    UPROPERTY(EditAnywhere, Category = Vector4, SaveGame)
    float Y;
 
    UPROPERTY(EditAnywhere, Category = Vector4, SaveGame)
    float Z;
 
    UPROPERTY(EditAnywhere, Category = Vector4, SaveGame)
    float W;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FVector4d
{
    UPROPERTY(EditAnywhere, Category = Vector4, SaveGame)
    double X;
 
    UPROPERTY(EditAnywhere, Category = Vector4, SaveGame)
    double Y;
 
    UPROPERTY(EditAnywhere, Category = Vector4, SaveGame)
    double Z;
 
    UPROPERTY(EditAnywhere, Category = Vector4, SaveGame)
    double W;
};
 
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta = (ScriptDefaultMake, ScriptDefaultBreak, HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeVector4", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakVector4"))
struct FVector4
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector4, SaveGame)
    FLargeWorldCoordinatesReal X;       //~ Alias for float/double depending on LWC status. Note: Will be refactored to double before UE5 ships.
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector4, SaveGame)
    FLargeWorldCoordinatesReal Y;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector4, SaveGame)
    FLargeWorldCoordinatesReal Z;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector4, SaveGame)
    FLargeWorldCoordinatesReal W;
};
 
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta = (ScriptDefaultMake, ScriptDefaultBreak, HasNativeMake="/Script/Engine.KismetMathLibrary.MakeVector2D", HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeVector2D", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakVector2D"))
struct FVector2f
{
    UPROPERTY(EditAnywhere, Category=Vector2D, SaveGame)
    float X;
 
    UPROPERTY(EditAnywhere, Category=Vector2D, SaveGame)
    float Y;
};
 
// LWC_TODO: CRITICAL! Name collision in UHT with FVector2D due to case insensitive FNames!
// USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
// struct FVector2d
// {
//  UPROPERTY(EditAnywhere, Category=Vector2D, SaveGame)
//  double X;
//
//  UPROPERTY(EditAnywhere, Category=Vector2D, SaveGame)
//  double Y;
// };
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta=(HasNativeMake="/Script/Engine.KismetMathLibrary.MakeVector2D", HasNativeBreak="/Script/Engine.KismetMathLibrary.BreakVector2D"))
struct FVector2D
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector2D, SaveGame)
    FLargeWorldCoordinatesReal X;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector2D, SaveGame)
    FLargeWorldCoordinatesReal Y;
};
 
USTRUCT(immutable, BlueprintType, noexport, IsAlwaysAccessible, HasDefaults)
struct FTwoVectors
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=TwoVectors, SaveGame)
    FVector v1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=TwoVectors, SaveGame)
    FVector v2;
};
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FPlane4f : public FVector3f
{
    UPROPERTY(EditAnywhere, Category=Plane, SaveGame)
    float W;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FPlane4d : public FVector3d
{
    UPROPERTY(EditAnywhere, Category = Plane, SaveGame)
    double W;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FPlane : public FVector
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Plane, SaveGame)
    FLargeWorldCoordinatesReal W;
};
 
 
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FRay3f
{
    UPROPERTY(EditAnywhere, Category = Ray, SaveGame)
    FVector3f Origin;
 
    UPROPERTY(EditAnywhere, Category = Ray, SaveGame)
    FVector3f Direction;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FRay3d
{
    UPROPERTY(EditAnywhere, Category = Ray, SaveGame)
    FVector3d Origin;
 
    UPROPERTY(EditAnywhere, Category = Ray, SaveGame)
    FVector3d Direction;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FRay
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Ray, SaveGame)
    FVector Origin;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Ray, SaveGame)
    FVector Direction;
};
 
 
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta = (ScriptDefaultMake, ScriptDefaultBreak, HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeRotator", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakRotator"))
struct FRotator3f
{
    UPROPERTY(EditAnywhere, Category=Rotator, SaveGame, meta=(DisplayName="Y"))
    float Pitch;
 
    UPROPERTY(EditAnywhere, Category=Rotator, SaveGame, meta=(DisplayName="Z"))
    float Yaw;
 
    UPROPERTY(EditAnywhere, Category=Rotator, SaveGame, meta=(DisplayName="X"))
    float Roll;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FRotator3d
{
    UPROPERTY(EditAnywhere, Category=Rotator, SaveGame, meta=(DisplayName="Y"))
    double Pitch;
 
    UPROPERTY(EditAnywhere, Category=Rotator, SaveGame, meta=(DisplayName="Z"))
    double Yaw;
 
    UPROPERTY(EditAnywhere, Category=Rotator, SaveGame, meta=(DisplayName="X"))
    double Roll;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta=(HasNativeMake="/Script/Engine.KismetMathLibrary.MakeRotator", HasNativeBreak="/Script/Engine.KismetMathLibrary.BreakRotator"))
struct FRotator
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Rotator, SaveGame, meta=(DisplayName="Y"))
    FLargeWorldCoordinatesReal Pitch;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Rotator, SaveGame, meta=(DisplayName="Z"))
    FLargeWorldCoordinatesReal Yaw;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Rotator, SaveGame, meta=(DisplayName="X"))
    FLargeWorldCoordinatesReal Roll;
};
 
 
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FSphere3f
{
    UPROPERTY(EditAnywhere, Category = Sphere, SaveGame)
    FVector3f Center;
 
    UPROPERTY(EditAnywhere, Category = Sphere, SaveGame, meta = (DisplayName = "Radius"))
    float W;
};
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FSphere3d
{
    UPROPERTY(EditAnywhere, Category = Sphere, SaveGame)
    FVector3d Center;
 
    UPROPERTY(EditAnywhere, Category = Sphere, SaveGame, meta = (DisplayName = "Radius"))
    double W;
};
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FSphere
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sphere, SaveGame)
    FVector Center;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sphere, SaveGame, meta = (DisplayName = "Radius"))
    FLargeWorldCoordinatesReal W;
};
 
 
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta = (ScriptDefaultMake, ScriptDefaultBreak, HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeQuat", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakQuat"))
struct FQuat4f
{
    UPROPERTY(EditAnywhere, Category=Quat, SaveGame)
    float X;
 
    UPROPERTY(EditAnywhere, Category=Quat, SaveGame)
    float Y;
 
    UPROPERTY(EditAnywhere, Category=Quat, SaveGame)
    float Z;
 
    UPROPERTY(EditAnywhere, Category=Quat, SaveGame)
    float W;
 
};
 
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FQuat4d
{
    UPROPERTY(EditAnywhere, Category = Quat, SaveGame)
    double X;
 
    UPROPERTY(EditAnywhere, Category = Quat, SaveGame)
    double Y;
 
    UPROPERTY(EditAnywhere, Category = Quat, SaveGame)
    double Z;
 
    UPROPERTY(EditAnywhere, Category = Quat, SaveGame)
    double W;
 
};
 
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta=(HasNativeMake ="/Script/Engine.KismetMathLibrary.MakeQuat", HasNativeBreak="/Script/Engine.KismetMathLibrary.BreakQuat"))
struct FQuat
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Quat, SaveGame)
    FLargeWorldCoordinatesReal X;       //~ Alias for float/double depending on LWC status. Note: Will be refactored to double before UE5 ships.
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Quat, SaveGame)
    FLargeWorldCoordinatesReal Y;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Quat, SaveGame)
    FLargeWorldCoordinatesReal Z;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Quat, SaveGame)
    FLargeWorldCoordinatesReal W;
};
 
 
USTRUCT(immutable, noexport)
struct FPackedNormal
{
    UPROPERTY(EditAnywhere, Category=PackedNormal, SaveGame)
    uint8 X;
 
    UPROPERTY(EditAnywhere, Category=PackedNormal, SaveGame)
    uint8 Y;
 
    UPROPERTY(EditAnywhere, Category=PackedNormal, SaveGame)
    uint8 Z;
 
    UPROPERTY(EditAnywhere, Category=PackedNormal, SaveGame)
    uint8 W;
 
};
 
USTRUCT(immutable, noexport)
struct FPackedRGB10A2N
{
    UPROPERTY(EditAnywhere, Category = PackedBasis, SaveGame)
    int32 Packed;
};
 
USTRUCT(immutable, noexport)
struct FPackedRGBA16N
{
    UPROPERTY(EditAnywhere, Category = PackedNormal, SaveGame)
    int32 XY;
 
    UPROPERTY(EditAnywhere, Category = PackedNormal, SaveGame)
    int32 ZW;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FIntPoint
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntPoint, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntPoint, SaveGame)
    int32 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt32Point
{
    UPROPERTY(EditAnywhere, Category = IntPoint, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, Category = IntPoint, SaveGame)
    int32 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt64Point
{
    UPROPERTY(EditAnywhere, Category=IntPoint, SaveGame)
    int64 X;
 
    UPROPERTY(EditAnywhere, Category=IntPoint, SaveGame)
    int64 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUintPoint
{
    UPROPERTY(EditAnywhere, Category = IntPoint, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, Category = IntPoint, SaveGame)
    int32 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint32Point
{
    UPROPERTY(EditAnywhere, Category = IntPoint, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, Category = IntPoint, SaveGame)
    int32 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint64Point
{
    UPROPERTY(EditAnywhere, Category = IntPoint, SaveGame)
    int64 X;
 
    UPROPERTY(EditAnywhere, Category = IntPoint, SaveGame)
    int64 Y;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FIntRect
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntRect, SaveGame)
    FIntPoint Min;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntRect, SaveGame)
    FIntPoint Max;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt32Rect
{
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FInt32Point Min;
 
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FInt32Point Max;    
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt64Rect
{
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FInt64Point Min;
 
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FInt64Point Max;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUintRect
{
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FUintPoint Min;
 
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FUintPoint Max;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint32Rect
{
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FUint32Point Min;
 
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FUint32Point Max;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint64Rect
{
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FUint64Point Min;
 
    UPROPERTY(EditAnywhere, Category=IntRect, SaveGame)
    FUint64Point Max;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt32Vector2
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt64Vector2
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 Y;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FIntVector2
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = IntVector, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = IntVector, SaveGame)
    int32 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint32Vector2
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint64Vector2
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 Y;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUintVector2
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 Y;
};
 
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt32Vector
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 Z;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt64Vector
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 Z;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FIntVector
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntVector, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntVector, SaveGame)
    int32 Y;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntVector, SaveGame)
    int32 Z;
};
 
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint32Vector
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 Z;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint64Vector
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 Z;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUintVector
{
    UPROPERTY(EditAnywhere, Category=IntVector, SaveGame)
    uint32 X;
 
    UPROPERTY(EditAnywhere, Category=IntVector, SaveGame)
    uint32 Y;
 
    UPROPERTY(EditAnywhere, Category=IntVector, SaveGame)
    uint32 Z;
};
 
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt32Vector4
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 Z;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int32 W;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FInt64Vector4
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 Z;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    int64 W;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FIntVector4
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = IntVector4, SaveGame)
    int32 X;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = IntVector4, SaveGame)
    int32 Y;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = IntVector4, SaveGame)
    int32 Z;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = IntVector4, SaveGame)
    int32 W;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint32Vector4
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 Z;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint32 W;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUint64Vector4
{
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 Z;
 
    UPROPERTY(EditAnywhere, Category = IntVector, SaveGame)
    uint64 W;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FUintVector4
{
    UPROPERTY(EditAnywhere, Category = IntVector4, SaveGame)
    uint32 X;
 
    UPROPERTY(EditAnywhere, Category = IntVector4, SaveGame)
    uint32 Y;
 
    UPROPERTY(EditAnywhere, Category = IntVector4, SaveGame)
    uint32 Z;
 
    UPROPERTY(EditAnywhere, Category = IntVector4, SaveGame)
    uint32 W;
};
 
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor)
struct FColor
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Color, SaveGame, meta=(ClampMin="0", ClampMax="255"))
    uint8 B;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Color, SaveGame, meta=(ClampMin="0", ClampMax="255"))
    uint8 G;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Color, SaveGame, meta=(ClampMin="0", ClampMax="255"))
    uint8 R;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Color, SaveGame, meta=(ClampMin="0", ClampMax="255"))
    uint8 A;
 
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor)
struct FLinearColor
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LinearColor, SaveGame)
    float R;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LinearColor, SaveGame)
    float G;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LinearColor, SaveGame)
    float B;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LinearColor, SaveGame)
    float A;
 
};
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FBox3f
{
    UPROPERTY(EditAnywhere, Category = Box, SaveGame, meta=(EditCondition="IsValid"))
    FVector3f Min;
 
    UPROPERTY(EditAnywhere, Category = Box, SaveGame, meta=(EditCondition="IsValid"))
    FVector3f Max;
 
    UPROPERTY(EditAnywhere, Category = Box, SaveGame, meta=(ScriptName="IsValid"))
    bool IsValid;
};
 
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FBox3d
{
    UPROPERTY(EditAnywhere, Category = Box, SaveGame, meta=(EditCondition="IsValid"))
    FVector3d Min;
 
    UPROPERTY(EditAnywhere, Category = Box, SaveGame, meta=(EditCondition="IsValid"))
    FVector3d Max;
 
    UPROPERTY(EditAnywhere, Category = Box, SaveGame, meta=(ScriptName="IsValid"))
    bool IsValid;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta=(HasNativeMake="/Script/Engine.KismetMathLibrary.MakeBox"))
struct FBox
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Box, SaveGame, meta=(EditCondition="IsValid"))
    FVector Min;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Box, SaveGame, meta=(EditCondition="IsValid"))
    FVector Max;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Box, SaveGame, meta=(ScriptName="IsValid"))
    bool IsValid;
};
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FBox2f
{
    UPROPERTY(EditAnywhere, Category=Box2D, SaveGame, meta=(EditCondition="bIsValid"))
    FVector2f Min;
 
    UPROPERTY(EditAnywhere, Category=Box2D, SaveGame, meta=(EditCondition="bIsValid"))
    FVector2f Max;
 
    UPROPERTY(EditAnywhere, Category=Box2D, SaveGame, meta=(ScriptName="bIsValid"))
    bool bIsValid;
};
 
// LWC_TODO: CRITICAL! Name collision in UHT with FBox2D due to case insensitive FNames!
// USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
// struct FBox2d
// {
//  UPROPERTY(EditAnywhere, Category=Box2D, SaveGame, meta=(EditCondition="bIsValid"))
//  FVector2d Min;
//
//  UPROPERTY(EditAnywhere, Category=Box2D, SaveGame, meta=(EditCondition="bIsValid"))
//  FVector2d Max;
//
//  UPROPERTY(EditAnywhere, Category=Box2D, SaveGame, meta=(ScriptName="bIsValid"))
//  bool bIsValid;
// };
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta=(HasNativeMake="/Script/Engine.KismetMathLibrary.MakeBox2D"))
struct FBox2D
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Box2D, SaveGame, meta=(EditCondition="bIsValid"))
    FVector2D Min;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Box2D, SaveGame, meta=(EditCondition="bIsValid"))
    FVector2D Max;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Box2D, SaveGame, meta=(ScriptName="bIsValid"))
    bool bIsValid;
};
 
USTRUCT(noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FBoxSphereBounds3f
{
    UPROPERTY(EditAnywhere, Category = BoxSphereBounds, SaveGame)
    FVector3f Origin;
 
    UPROPERTY(EditAnywhere, Category = BoxSphereBounds, SaveGame)
    FVector3f BoxExtent;
 
    UPROPERTY(EditAnywhere, Category = BoxSphereBounds, SaveGame)
    float SphereRadius;
};
 
USTRUCT(noexport, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FBoxSphereBounds3d
{
    UPROPERTY(EditAnywhere, Category = BoxSphereBounds, SaveGame)
    FVector3d Origin;
 
    UPROPERTY(EditAnywhere, Category = BoxSphereBounds, SaveGame)
    FVector3d BoxExtent;
 
    UPROPERTY(EditAnywhere, Category = BoxSphereBounds, SaveGame)
    double SphereRadius;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, IsCoreType, meta = (HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeBoxSphereBounds", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakBoxSphereBounds"))
struct FBoxSphereBounds
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BoxSphereBounds, SaveGame)
    FVector Origin;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BoxSphereBounds, SaveGame)
    FVector BoxExtent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BoxSphereBounds, SaveGame)
    FLargeWorldCoordinatesReal SphereRadius;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, meta = (HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeOrientedBox"))
struct FOrientedBox
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
    FVector Center;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=OrientedBox, SaveGame)
    FVector AxisX;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=OrientedBox, SaveGame)
    FVector AxisY;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=OrientedBox, SaveGame)
    FVector AxisZ;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
    FLargeWorldCoordinatesReal ExtentX;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
    FLargeWorldCoordinatesReal ExtentY;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
    FLargeWorldCoordinatesReal ExtentZ;
};
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FMatrix44f
{
    UPROPERTY(EditAnywhere, Category=Matrix, SaveGame)
    FPlane4f XPlane;
 
    UPROPERTY(EditAnywhere, Category=Matrix, SaveGame)
    FPlane4f YPlane;
 
    UPROPERTY(EditAnywhere, Category=Matrix, SaveGame)
    FPlane4f ZPlane;
 
    UPROPERTY(EditAnywhere, Category=Matrix, SaveGame)
    FPlane4f WPlane;
 
};
 
USTRUCT(immutable, noexport, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FMatrix44d
{
    UPROPERTY(EditAnywhere, Category = Matrix, SaveGame)
    FPlane4d XPlane;
 
    UPROPERTY(EditAnywhere, Category = Matrix, SaveGame)
    FPlane4d YPlane;
 
    UPROPERTY(EditAnywhere, Category = Matrix, SaveGame)
    FPlane4d ZPlane;
 
    UPROPERTY(EditAnywhere, Category = Matrix, SaveGame)
    FPlane4d WPlane;
 
};
 
USTRUCT(immutable, noexport, BlueprintType, HasDefaults, HasNoOpConstructor, IsCoreType)
struct FMatrix
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Matrix, SaveGame)
    FPlane XPlane;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Matrix, SaveGame)
    FPlane YPlane;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Matrix, SaveGame)
    FPlane ZPlane;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Matrix, SaveGame)
    FPlane WPlane;
 
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor)
struct FInterpCurvePointFloat
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
    float InVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
    float OutVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
    float ArriveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
    float LeaveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
    TEnumAsByte<enum EInterpCurveMode> InterpMode;
 
};
 
USTRUCT(noexport, BlueprintType)
struct FInterpCurveFloat
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveFloat)
    TArray<FInterpCurvePointFloat> Points;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveFloat)
    bool bIsLooped;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveFloat)
    float LoopKeyOffset;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor)
struct FInterpCurvePointVector2D
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
    float InVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
    FVector2D OutVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
    FVector2D ArriveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
    FVector2D LeaveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
    TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
 
USTRUCT(noexport, BlueprintType)
struct FInterpCurveVector2D
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector2D)
    TArray<FInterpCurvePointVector2D> Points;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector2D)
    bool bIsLooped;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector2D)
    float LoopKeyOffset;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor)
struct FInterpCurvePointVector
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
    float InVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
    FVector OutVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
    FVector ArriveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
    FVector LeaveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
    TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
 
USTRUCT(noexport, BlueprintType)
struct FInterpCurveVector
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector)
    TArray<FInterpCurvePointVector> Points;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector)
    bool bIsLooped;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector)
    float LoopKeyOffset;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor)
struct FInterpCurvePointQuat
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
    float InVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
    FQuat OutVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
    FQuat ArriveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
    FQuat LeaveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
    TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
 
USTRUCT(noexport, BlueprintType)
struct FInterpCurveQuat
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveQuat)
    TArray<FInterpCurvePointQuat> Points;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveQuat)
    bool bIsLooped;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveQuat)
    float LoopKeyOffset;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor)
struct FInterpCurvePointTwoVectors
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
    float InVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
    FTwoVectors OutVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
    FTwoVectors ArriveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
    FTwoVectors LeaveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
    TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
 
USTRUCT(noexport, BlueprintType)
struct FInterpCurveTwoVectors
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveTwoVectors)
    TArray<FInterpCurvePointTwoVectors> Points;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveTwoVectors)
    bool bIsLooped;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveTwoVectors)
    float LoopKeyOffset;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor)
struct FInterpCurvePointLinearColor
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
    float InVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
    FLinearColor OutVal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
    FLinearColor ArriveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
    FLinearColor LeaveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
    TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
 
USTRUCT(noexport, BlueprintType)
struct FInterpCurveLinearColor
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveLinearColor)
    TArray<FInterpCurvePointLinearColor> Points;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveLinearColor)
    bool bIsLooped;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveLinearColor)
    float LoopKeyOffset;
};
 
USTRUCT(immutable, noexport, BlueprintType, BlueprintInternalUseOnly, IsAlwaysAccessible, HasDefaults, IsCoreType, meta = (ScriptDefaultMake, ScriptDefaultBreak, HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeTransform", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakTransform"))
struct FTransform3f
{
    UPROPERTY(EditAnywhere, Category = Transform, SaveGame)
    FQuat4f Rotation;
 
    UPROPERTY(EditAnywhere, Category = Transform, SaveGame)
    FVector3f Translation;
 
    UPROPERTY(EditAnywhere, Category = Transform, SaveGame)
    FVector3f Scale3D;
};
 
USTRUCT(immutable, noexport, IsAlwaysAccessible, HasDefaults, IsCoreType)
struct FTransform3d
{
    UPROPERTY(EditAnywhere, Category = Transform, SaveGame)
    FQuat4d Rotation;
 
    UPROPERTY(EditAnywhere, Category = Transform, SaveGame)
    FVector3d Translation;
 
    UPROPERTY(EditAnywhere, Category = Transform, SaveGame)
    FVector3d Scale3D;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, IsCoreType, meta=(HasNativeMake="/Script/Engine.KismetMathLibrary.MakeTransform", HasNativeBreak="/Script/Engine.KismetMathLibrary.BreakTransform"))
struct FTransform
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Transform, SaveGame)
    FQuat Rotation;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Transform, SaveGame)
    FVector Translation;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Transform, SaveGame)
    FVector Scale3D;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, HasNoOpConstructor, meta = (HasNativeMake = "/Script/Engine.KismetMathLibrary.MakeRandomStream", HasNativeBreak = "/Script/Engine.KismetMathLibrary.BreakRandomStream"))
struct FRandomStream
{
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=RandomStream, SaveGame)
    int32 InitialSeed;
    
    UPROPERTY()
    int32 Seed;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, meta=(HasNativeMake="/Script/Engine.KismetMathLibrary.MakeDateTime", HasNativeBreak="/Script/Engine.KismetMathLibrary.BreakDateTime"))
struct FDateTime
{
    UPROPERTY()
    int64 Ticks;
};
 
USTRUCT(noexport, BlueprintType, IsAlwaysAccessible, HasDefaults)
struct FFrameNumber
{
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category=FrameNumber)
    int32 Value;
};
 
USTRUCT(noexport, BlueprintType, meta=(HasNativeMake="/Script/Engine.KismetMathLibrary.MakeFrameRate", HasNativeBreak="/Script/Engine.KismetMathLibrary.BreakFrameRate"))
struct FFrameRate
{
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category=FrameRate)
    int32 Numerator;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category=FrameRate)
    int32 Denominator;
};
 
USTRUCT(noexport, BlueprintType)
struct FFrameTime
{
    UPROPERTY(BlueprintReadWrite, Category=FrameTime)
    FFrameNumber FrameNumber;
    
private:
    UPROPERTY(BlueprintReadWrite, Category=FrameTime, meta=(AllowPrivateAccess="true"))
    float SubFrame;
};
 
USTRUCT(noexport, BlueprintType, meta=(ScriptName="QualifiedTime", HasNativeMake="/Script/Engine.KismetMathLibrary.MakeQualifiedFrameTime", HasNativeBreak="/Script/Engine.KismetMathLibrary.BreakQualifiedFrameTime"))
struct FQualifiedFrameTime
{
    UPROPERTY(BlueprintReadWrite, Category=QualifiedFrameTime)
    FFrameTime Time;
 
    UPROPERTY(BlueprintReadWrite, Category=QualifiedFrameTime)
    FFrameRate Rate;
};
 
USTRUCT(noexport, BlueprintType)
struct FTimecode
{
    UPROPERTY(BlueprintReadWrite, Category=Timecode)
    int32 Hours;
 
    UPROPERTY(BlueprintReadWrite, Category=Timecode)
    int32 Minutes;
 
    UPROPERTY(BlueprintReadWrite, Category=Timecode)
    int32 Seconds;
 
    UPROPERTY(BlueprintReadWrite, Category=Timecode)
    int32 Frames;
 
    UPROPERTY(BlueprintReadWrite, Category=Timecode)
    float Subframe;
 
    UPROPERTY(BlueprintReadWrite, Category= Timecode)
    bool bDropFrameFormat;
};
 
USTRUCT(immutable, noexport, BlueprintType, IsAlwaysAccessible, HasDefaults, meta=(HasNativeMake="/Script/Engine.KismetMathLibrary.MakeTimespan", HasNativeBreak="/Script/Engine.KismetMathLibrary.BreakTimespan"))
struct FTimespan
{
    UPROPERTY()
    int64 Ticks;
};
 
USTRUCT(noexport, BlueprintType)
struct FMusicalTime
{
    UPROPERTY()
    int32 Bar;
    
    UPROPERTY()
    int32 TickInBar;
 
    UPROPERTY()
    int32 TicksPerBar;
 
    UPROPERTY()
    int32 TicksPerBeat;
};
 
UENUM(BlueprintType)
namespace ERangeBoundTypes
{
    enum Type : int
    {
        Exclusive,
 
        Inclusive,
 
        Open
    };
}
 
USTRUCT(noexport, BlueprintType)
struct FFloatRangeBound
{
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    TEnumAsByte<ERangeBoundTypes::Type> Type;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    float Value;
};
 
USTRUCT(noexport, BlueprintType)
struct FFloatRange
{
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FFloatRangeBound LowerBound;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FFloatRangeBound UpperBound;
};
 
 
USTRUCT(noexport, BlueprintType)
struct FDoubleRangeBound
{
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    TEnumAsByte<ERangeBoundTypes::Type> Type;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    double Value;
};
 
USTRUCT(noexport, BlueprintType)
struct FDoubleRange
{
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FDoubleRangeBound LowerBound;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FDoubleRangeBound UpperBound;
};
 
USTRUCT(noexport, BlueprintType)
struct FInt32RangeBound
{
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    TEnumAsByte<ERangeBoundTypes::Type> Type;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    int32 Value;
};
 
USTRUCT(noexport, BlueprintType)
struct FInt32Range
{
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FInt32RangeBound LowerBound;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FInt32RangeBound UpperBound;
};
 
USTRUCT(noexport, BlueprintType)
struct FFrameNumberRangeBound
{
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    TEnumAsByte<ERangeBoundTypes::Type> Type;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FFrameNumber Value;
};
 
USTRUCT(noexport, BlueprintType)
struct FFrameNumberRange
{
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FFrameNumberRangeBound LowerBound;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Range, meta=(AllowPrivateAccess="true"))
    FFrameNumberRangeBound UpperBound;
};
 
USTRUCT(noexport, BlueprintType)
struct FFloatInterval
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Interval)
    float Min;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Interval)
    float Max;
};
 
USTRUCT(noexport, BlueprintType)
struct FInt32Interval
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Interval)
    int32 Min;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Interval)
    int32 Max;
};
 
UENUM(BlueprintType)
enum class ELocalizedTextSourceCategory : uint8
{
    Game,
    Engine,
    Editor,
};
 
USTRUCT(noexport, BlueprintType)
struct FPolyglotTextData
{
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PolyglotData)
    ELocalizedTextSourceCategory Category;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PolyglotData)
    FString NativeCulture;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PolyglotData)
    FString Namespace;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PolyglotData)
    FString Key;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PolyglotData)
    FString NativeString;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PolyglotData)
    TMap<FString, FString> LocalizedStrings;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PolyglotData)
    bool bIsMinimalPatch;
 
    UPROPERTY(Transient)
    FText CachedText;
};
 
UENUM()
enum class EAutomationEventType : uint8
{
    Info,
    Warning,
    Error
};
 
USTRUCT(noexport)
struct FAutomationEvent
{
    UPROPERTY()
    EAutomationEventType Type;
 
    UPROPERTY()
    FString Message;
 
    UPROPERTY()
    FString Context;
 
    UPROPERTY()
    FGuid Artifact;
};
 
USTRUCT(noexport)
struct FAutomationExecutionEntry
{
    UPROPERTY()
    FAutomationEvent Event;
 
    UPROPERTY()
    FString Filename;
 
    UPROPERTY()
    int32 LineNumber;
 
    UPROPERTY()
    FDateTime Timestamp;
};
 
 
USTRUCT(noexport, BlueprintType)
struct FInputDeviceId
{
    GENERATED_BODY()
private:
    
    UPROPERTY(VisibleAnywhere, Category = "PlatformInputDevice")
    int32 InternalId = -1;
};
 
USTRUCT(noexport, BlueprintType)
struct FPlatformUserId
{
    GENERATED_BODY()
private:
    
    UPROPERTY(VisibleAnywhere, Category = "PlatformInputDevice")
    int32 InternalId = -1;
};
 
UENUM(BlueprintType)
enum class EInputDeviceConnectionState : uint8
{
    Invalid,
 
    Unknown,
 
    Disconnected,
 
    Connected
};
 
UENUM()
enum class EInputDeviceMappingPolicy : int32
{
    Invalid = -1 UMETA(Hidden),
    
    UseManagedPlatformLogin = 0,
    
    PrimaryUserSharesKeyboardAndFirstGamepad = 1,
 
    CreateUniquePlatformUserForEachDevice = 2,
 
    MapAllDevicesToPrimaryUser = 3
};
 
UENUM(BlueprintType)
enum class EInputDeviceTriggerMask : uint8
{
    None        = 0x00,
    Left        = 0x01,
    Right       = 0x02,
    All         = Left | Right
};
 
UENUM(BlueprintType)
enum class EInputDeviceAnalogStickMask : uint8
{
    None = 0x00,
    Left = 0x01,
    Right = 0x02
};
 
USTRUCT(noexport, BlueprintType)
struct FPlatformInputDeviceState
{
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category = "PlatformInputDevice")
    FPlatformUserId OwningPlatformUser = PLATFORMUSERID_NONE;
 
    UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category = "PlatformInputDevice")
    EInputDeviceConnectionState ConnectionState = EInputDeviceConnectionState::Invalid;
};
 
UENUM(BlueprintType)
enum class EDataValidationResult : uint8
{
    Invalid,
    Valid,
    NotValidated
};
 
USTRUCT(noexport, BlueprintType)
struct FRemoteObjectId
{
    GENERATED_BODY()
 
    UPROPERTY()
    uint64 Id;
};
 
USTRUCT(noexport, BlueprintType)
struct FPackedRemoteObjectPathName
{
    GENERATED_BODY()
 
    UPROPERTY()
    TArray<uint16> RemoteIds;
 
    UPROPERTY()
    TArray<uint16> Names;
};
 
USTRUCT(noexport, BlueprintType)
struct FRemoteObjectBytes
{
    UPROPERTY()
    TArray<uint8> Bytes;
};
 
USTRUCT(noexport, BlueprintType)
struct FRemoteObjectTables
{
    UPROPERTY()
    TArray<FName> Names;
 
    UPROPERTY()
    TArray<FRemoteObjectId> RemoteIds;
};
 
USTRUCT(noexport)
struct FRemoteObjectPathName : public FRemoteObjectTables
{
    GENERATED_BODY()
};
 
USTRUCT(noexport, BlueprintType)
struct FRemoteObjectData
{
    GENERATED_BODY()
 
    UPROPERTY()
    FRemoteObjectTables Tables;
 
    UPROPERTY()
    TArray<FPackedRemoteObjectPathName> PathNames;
 
    UPROPERTY()
    TArray<FRemoteObjectBytes> Bytes;
};
 
USTRUCT(noexport, BlueprintType)
struct FRemoteServerId
{
    GENERATED_BODY()
 
    UPROPERTY()
    uint32 Id;
};
 
USTRUCT(noexport, BlueprintType)
struct FRemoteWorkPriority
{
    GENERATED_BODY()
 
    UPROPERTY()
    uint64 PackedData;
};
 
USTRUCT(noexport, BlueprintType)
struct FRemoteObjectReference
{
    GENERATED_BODY()
 
    UPROPERTY()
    FRemoteObjectId ObjectId;
 
    UPROPERTY()
    FRemoteServerId ServerId;
};
 
USTRUCT(noexport, BlueprintType)
struct FRemoteTransactionId
{
    GENERATED_BODY()
 
    UPROPERTY()
    uint32 Id;
};
 
 
#endif